@synapsor/runner 1.6.2 → 1.6.3

package/dist/runtime.mjs

@@ -158,7 +158,7 @@ var SUBJECT_KEYS = /* @__PURE__ */ new Set(["resource", "schema", "table", "prim
 var ARG_KEYS = /* @__PURE__ */ new Set(["type", "description", "required", "max_length", "minimum", "maximum", "enum", "max_items", "fields"]);
 var LOOKUP_KEYS = /* @__PURE__ */ new Set(["id_from_arg"]);
 var EVIDENCE_KEYS = /* @__PURE__ */ new Set(["required", "sources", "query_audit", "handle_prefix"]);
-var PROPOSAL_KEYS = /* @__PURE__ */ new Set(["action", "operation", "allowed_fields", "patch", "numeric_bounds", "transition_guards", "reversibility", "conflict_guard", "approval", "writeback"]);
+var PROPOSAL_KEYS = /* @__PURE__ */ new Set(["action", "operation", "allowed_fields", "patch", "numeric_bounds", "transition_guards", "reversibility", "conflict_guard", "approval", "execution", "writeback"]);
 var OPERATION_KEYS = /* @__PURE__ */ new Set(["kind", "cardinality", "selection", "max_rows", "aggregate_bounds", "batch", "deduplication", "version_advance"]);
 var SELECTION_KEYS = /* @__PURE__ */ new Set(["all"]);
 var PREDICATE_TERM_KEYS = /* @__PURE__ */ new Set(["column", "operator", "value"]);
@@ -173,6 +173,7 @@ 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", "required_approvals", "policy"]);
+var EXECUTION_KEYS = /* @__PURE__ */ new Set(["supervised_worker"]);
 var WRITEBACK_KEYS = /* @__PURE__ */ new Set(["mode", "executor", "idempotency_key"]);
 var REVERSIBILITY_KEYS = /* @__PURE__ */ new Set(["mode"]);
 var AGGREGATE_READ_KEYS = /* @__PURE__ */ new Set(["function", "count_mode", "column", "selection", "minimum_group_size"]);
@@ -394,8 +395,8 @@ function validateContexts(value, errors, warnings) {
 }
 function validateCapabilities(value, contextNames, resourceNames, errors, warnings) {
   const names = /* @__PURE__ */ new Set();
-  if (!Array.isArray(value) || value.length === 0) {
-    errors.push({ path: "$.capabilities", code: "CAPABILITIES_REQUIRED", message: "At least one capability is required." });
+  if (!Array.isArray(value)) {
+    errors.push({ path: "$.capabilities", code: "CAPABILITIES_REQUIRED", message: "capabilities must be an array; an empty array represents zero authority." });
     return names;
   }
   value.forEach((capability, index) => {
@@ -1122,6 +1123,55 @@ function validateProposalAction(value, subject, path3, errors) {
       });
     }
   }
+  if (value.execution !== void 0) {
+    validateNestedObject(value.execution, EXECUTION_KEYS, `${path3}.execution`, errors);
+    if (isRecord(value.execution) && value.execution.supervised_worker !== "allowed") {
+      errors.push({
+        path: `${path3}.execution.supervised_worker`,
+        code: "INVALID_SUPERVISED_WORKER_PERMISSION",
+        message: "execution.supervised_worker must be allowed when the optional permission is present."
+      });
+    }
+    if (isRecord(value.execution) && value.execution.supervised_worker === "allowed") {
+      const cardinality = isRecord(value.operation) ? value.operation.cardinality ?? "single" : "single";
+      const writebackMode = isRecord(value.writeback) ? value.writeback.mode : "direct_sql";
+      if (writebackMode !== "direct_sql") {
+        errors.push({
+          path: `${path3}.writeback.mode`,
+          code: "SUPERVISED_WORKER_DIRECT_SQL_REQUIRED",
+          message: "supervised-worker execution is initially limited to Runner-owned direct_sql writeback."
+        });
+      }
+      if (cardinality !== "single") {
+        errors.push({
+          path: `${path3}.operation.cardinality`,
+          code: "SUPERVISED_WORKER_SINGLE_ROW_REQUIRED",
+          message: "supervised-worker execution is initially limited to deterministic single-row writes."
+        });
+      }
+      if (deleteOperation) {
+        errors.push({
+          path: `${path3}.operation.kind`,
+          code: "SUPERVISED_WORKER_DELETE_FORBIDDEN",
+          message: "hard DELETE is not eligible for supervised-worker execution in this release."
+        });
+      }
+      if (value.reversibility !== void 0) {
+        errors.push({
+          path: `${path3}.reversibility`,
+          code: "SUPERVISED_WORKER_REVERSIBILITY_FORBIDDEN",
+          message: "reviewed compensation actions require manual execution in this release."
+        });
+      }
+      if (operation === "update" && (!isRecord(value.conflict_guard) || !isSafeIdentifier(value.conflict_guard.column) || value.conflict_guard.weak_guard_ack === true)) {
+        errors.push({
+          path: `${path3}.conflict_guard.column`,
+          code: "SUPERVISED_WORKER_EXACT_CONFLICT_GUARD_REQUIRED",
+          message: "supervised-worker UPDATE requires an exact source version/conflict column; a weak row hash is not eligible."
+        });
+      }
+    }
+  }
   if (value.writeback !== void 0) {
     validateNestedObject(value.writeback, WRITEBACK_KEYS, `${path3}.writeback`, errors);
     if (isRecord(value.writeback) && !["direct_sql", "app_handler", "cloud_worker", "none"].includes(String(value.writeback.mode)))
@@ -1467,7 +1517,7 @@ function validatePolicies(value, errors) {
       if (!Array.isArray(policy.rules)) {
         errors.push({ path: `${path3}.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, `${path3}.rules[${ruleIndex}]`, errors));
+        policy.rules.forEach((rule2, ruleIndex) => validateApprovalPolicyRuleShape(rule2, `${path3}.rules[${ruleIndex}]`, errors));
       }
     }
     if (policy.limits !== void 0) {
@@ -1507,16 +1557,16 @@ function validateApprovalPolicyLimitShape(limit, path3, errors) {
     errors.push({ path: `${path3}.field`, code: "APPROVAL_POLICY_COUNT_FIELD_FORBIDDEN", message: "count approval limits must not declare a field." });
   }
 }
-function validateApprovalPolicyRuleShape(rule, path3, errors) {
-  if (!isRecord(rule)) {
+function validateApprovalPolicyRuleShape(rule2, path3, errors) {
+  if (!isRecord(rule2)) {
     errors.push({ path: path3, code: "APPROVAL_POLICY_RULE_NOT_OBJECT", message: "approval policy rules must be objects." });
     return;
   }
   const keys = /* @__PURE__ */ new Set(["field", "max"]);
-  checkUnknownKeys(rule, keys, path3, errors);
-  if (!isSafeIdentifier(rule.field))
+  checkUnknownKeys(rule2, keys, path3, errors);
+  if (!isSafeIdentifier(rule2.field))
     errors.push({ path: `${path3}.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)
+  if (!Number.isInteger(rule2.max) || Number(rule2.max) < 0)
     errors.push({ path: `${path3}.max`, code: "INVALID_APPROVAL_POLICY_MAX", message: "approval policy rule max must be a non-negative integer." });
 }
 function validateCapabilityApprovalPolicies(capabilities, policies, policyByName, errors) {
@@ -1563,11 +1613,11 @@ function validateApprovalPolicyRulesAgainstCapability(policy, policyIndex, capab
   if (!proposal)
     return;
   if (Array.isArray(policy.rules))
-    policy.rules.forEach((rule, ruleIndex) => {
-      if (!isRecord(rule))
+    policy.rules.forEach((rule2, ruleIndex) => {
+      if (!isRecord(rule2))
         return;
-      const field = rule.field;
-      const max = rule.max;
+      const field = rule2.field;
+      const max = rule2.max;
       const rulePath = `$.policies[${policyIndex}].rules[${ruleIndex}]`;
       if (!isSafeIdentifier(field) || !Number.isInteger(max))
         return;
@@ -1787,7 +1837,7 @@ function sortJson(value) {
 }
 
 // packages/config/src/index.ts
-var TOP_LEVEL_KEYS2 = /* @__PURE__ */ new Set(["version", "mode", "storage", "sources", "trusted_context", "contexts", "executors", "capabilities", "contracts", "policies", "approvals", "proposal_freshness", "operator_identity", "session_auth", "http_security", "rate_limits", "metrics", "graduated_trust", "cloud", "governance", "generated_authority", "strict", "result_format"]);
+var TOP_LEVEL_KEYS2 = /* @__PURE__ */ new Set(["version", "mode", "storage", "sources", "trusted_context", "contexts", "executors", "capabilities", "contracts", "policies", "approvals", "proposal_freshness", "operator_identity", "session_auth", "http_security", "rate_limits", "metrics", "graduated_trust", "cloud", "governance", "generated_authority", "supervised_worker", "notifications", "strict", "result_format"]);
 var STORAGE_KEYS = /* @__PURE__ */ new Set(["sqlite_path", "shared_postgres"]);
 var SHARED_POSTGRES_STORAGE_KEYS = /* @__PURE__ */ new Set(["mode", "url_env", "schema", "lock_timeout_ms", "max_entries"]);
 var APPROVALS_KEYS = /* @__PURE__ */ new Set(["disable_auto_approval"]);
@@ -1876,6 +1926,95 @@ var RATE_LIMIT_RULE_KEYS = /* @__PURE__ */ new Set(["requests", "window_seconds"
 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 GOVERNANCE_KEYS = /* @__PURE__ */ new Set(["mode", "connection_file", "evidence_residency", "queue_when_unavailable", "sync_interval_ms", "max_attempts", "outbox_retention_days"]);
 var GENERATED_AUTHORITY_KEYS = /* @__PURE__ */ new Set(["generation_lock_path", "enforcement"]);
+var SUPERVISED_WORKER_KEYS = /* @__PURE__ */ new Set(["enabled", "profile", "capabilities"]);
+var SUPERVISED_WORKER_CAPABILITY_KEYS = /* @__PURE__ */ new Set([
+  "capability",
+  "contract_digest",
+  "mode",
+  "concurrency",
+  "queue_limit",
+  "lease_seconds",
+  "max_attempts",
+  "proposal_ttl_seconds",
+  "rate_limit",
+  "write_url_env",
+  "require_least_privilege_writer",
+  "writer_posture_fingerprint",
+  "worker_identity",
+  "control_role",
+  "required_attention_sinks"
+]);
+var SUPERVISED_WORKER_RATE_LIMIT_KEYS = /* @__PURE__ */ new Set(["executions", "window_seconds"]);
+var NOTIFICATION_KEYS = /* @__PURE__ */ new Set(["enabled", "workbench_url_env", "sinks"]);
+var NOTIFICATION_SINK_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "enabled",
+  "url_env",
+  "signing_secret_env",
+  "destination",
+  "minimum_severity",
+  "events",
+  "capabilities",
+  "environments",
+  "delivery",
+  "max_attempts",
+  "timeout_ms",
+  "max_response_bytes",
+  "replay_window_seconds",
+  "allow_private_destinations",
+  "private_host_allowlist",
+  "recovery_notifications",
+  "budgets",
+  "quiet_hours"
+]);
+var NOTIFICATION_BUDGET_KEYS = /* @__PURE__ */ new Set([
+  "per_minute",
+  "per_hour",
+  "immediate_informational_per_hour",
+  "aggregation_window_seconds",
+  "cooldown_seconds",
+  "max_unresolved_reminders",
+  "digest_cadence_minutes",
+  "escalation_delay_seconds",
+  "retry_attempt_threshold",
+  "degraded_duration_seconds",
+  "queue_depth_threshold",
+  "queue_age_seconds"
+]);
+var NOTIFICATION_QUIET_HOURS_KEYS = /* @__PURE__ */ new Set(["start_utc_hour", "end_utc_hour"]);
+var NOTIFICATION_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "proposal.created",
+  "proposal.review_required",
+  "proposal.auto_approved",
+  "proposal.approved",
+  "proposal.queued",
+  "proposal.expiring",
+  "proposal.expired",
+  "proposal.cancelled",
+  "proposal.applied",
+  "proposal.conflict",
+  "proposal.refused",
+  "worker.started",
+  "worker.paused",
+  "worker.unhealthy",
+  "worker.recovered",
+  "worker.queue_backlog",
+  "worker.retry_scheduled",
+  "worker.dead_lettered",
+  "worker.unknown_outcome",
+  "worker.reconciliation_required",
+  "capability.review_required",
+  "capability.activated",
+  "capability.revoked",
+  "contract.digest_stale",
+  "schema.drift_detected",
+  "credential.posture_changed",
+  "policy.limit_near",
+  "policy.limit_exceeded",
+  "sensitive_override_activated",
+  "notification.replayed"
+]);
 var SOURCE_KEYS = /* @__PURE__ */ new Set([
   "engine",
   "read_url_env",
@@ -1917,6 +2056,7 @@ var CAPABILITY_KEYS2 = /* @__PURE__ */ new Set([
   "reversibility",
   "conflict_guard",
   "approval",
+  "execution",
   "writeback",
   "operation",
   "single_tenant_dev_ack",
@@ -1935,6 +2075,7 @@ var TRANSITION_GUARD_KEYS2 = /* @__PURE__ */ new Set(["from_column", "allowed"])
 var REVERSIBILITY_KEYS2 = /* @__PURE__ */ new Set(["mode"]);
 var CONFLICT_GUARD_KEYS2 = /* @__PURE__ */ new Set(["column", "weak_guard_ack"]);
 var APPROVAL_KEYS2 = /* @__PURE__ */ new Set(["mode", "required_role", "required_approvals", "policy"]);
+var EXECUTION_KEYS2 = /* @__PURE__ */ new Set(["supervised_worker"]);
 var POLICY_KEYS2 = /* @__PURE__ */ new Set(["name", "kind", "mode", "rules", "limits"]);
 var APPROVAL_POLICY_RULE_KEYS = /* @__PURE__ */ new Set(["field", "max"]);
 var APPROVAL_POLICY_LIMIT_KEYS2 = /* @__PURE__ */ new Set(["kind", "max", "period", "field", "scope"]);
@@ -2036,7 +2177,20 @@ function validateRunnerCapabilityConfig(input) {
   validateRateLimits(input.rate_limits, strict, errors);
   validateMetrics(input.metrics, strict, errors);
   validateGraduatedTrust(input.graduated_trust, strict, errors);
-  validateCapabilities2(input.capabilities, input.sources, input.contexts, input.executors, input.mode, strict, errors, warnings, hasContracts);
+  validateCapabilities2(
+    input.capabilities,
+    input.sources,
+    input.contexts,
+    input.executors,
+    input.mode,
+    strict,
+    errors,
+    warnings,
+    hasContracts,
+    input.generated_authority
+  );
+  validateNotifications(input.notifications, strict, errors);
+  validateSupervisedWorker(input.supervised_worker, input, strict, errors);
   validateProposalFreshness(input.proposal_freshness, input.capabilities, strict, errors);
   validateEffectiveContextCompatibility(input.trusted_context, input.contexts, input.capabilities, errors);
   validateApprovalPolicyReferences(input.capabilities, input.policies, errors);
@@ -2058,6 +2212,314 @@ function validateGeneratedAuthority(value, strict, errors) {
     errors.push({ path: "$.generated_authority.enforcement", code: "INVALID_GENERATION_LOCK_ENFORCEMENT", message: "generated authority must use required lock enforcement." });
   }
 }
+function validateNotifications(value, strict, errors) {
+  if (value === void 0) return;
+  if (!isRecord2(value)) {
+    errors.push({ path: "$.notifications", code: "NOTIFICATIONS_NOT_OBJECT", message: "notifications must be an operator-owned configuration object." });
+    return;
+  }
+  if (strict) checkUnknownKeys2(value, NOTIFICATION_KEYS, "$.notifications", errors);
+  if (typeof value.enabled !== "boolean") {
+    errors.push({ path: "$.notifications.enabled", code: "NOTIFICATIONS_ENABLED_REQUIRED", message: "notifications.enabled must be an explicit boolean." });
+  }
+  if (value.workbench_url_env !== void 0 && !isEnvName(value.workbench_url_env)) {
+    errors.push({ path: "$.notifications.workbench_url_env", code: "INVALID_WORKBENCH_URL_ENV", message: "workbench_url_env must name an environment variable, not contain a URL." });
+  }
+  if (!Array.isArray(value.sinks)) {
+    errors.push({ path: "$.notifications.sinks", code: "NOTIFICATION_SINKS_REQUIRED", message: "notifications.sinks must be an explicit array." });
+    return;
+  }
+  if (value.sinks.length > 32) {
+    errors.push({ path: "$.notifications.sinks", code: "TOO_MANY_NOTIFICATION_SINKS", message: "notifications supports at most 32 operator-owned sinks." });
+  }
+  if (value.enabled === true && value.sinks.filter(isRecord2).every((sink) => sink.enabled === false)) {
+    errors.push({ path: "$.notifications.sinks", code: "ENABLED_NOTIFICATION_SINK_REQUIRED", message: "enabled notifications require at least one sink that is not disabled." });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, rawSink] of value.sinks.entries()) {
+    const path3 = `$.notifications.sinks[${index}]`;
+    if (!isRecord2(rawSink)) {
+      errors.push({ path: path3, code: "NOTIFICATION_SINK_NOT_OBJECT", message: "each notification sink must be an object." });
+      continue;
+    }
+    if (strict) checkUnknownKeys2(rawSink, NOTIFICATION_SINK_KEYS, path3, errors);
+    if (!isSafeName(rawSink.id)) {
+      errors.push({ path: `${path3}.id`, code: "INVALID_NOTIFICATION_SINK_ID", message: "notification sink id must be a fixed safe name." });
+    } else if (seen.has(rawSink.id)) {
+      errors.push({ path: `${path3}.id`, code: "DUPLICATE_NOTIFICATION_SINK_ID", message: "notification sink ids must be unique." });
+    } else seen.add(rawSink.id);
+    if (rawSink.type !== "webhook" && rawSink.type !== "jsonl") {
+      errors.push({ path: `${path3}.type`, code: "INVALID_NOTIFICATION_SINK_TYPE", message: "notification sink type must be webhook or jsonl." });
+    }
+    if (rawSink.enabled !== void 0 && typeof rawSink.enabled !== "boolean") {
+      errors.push({ path: `${path3}.enabled`, code: "INVALID_NOTIFICATION_SINK_ENABLED", message: "notification sink enabled must be boolean." });
+    }
+    if (rawSink.type === "webhook") {
+      if (!isEnvName(rawSink.url_env)) {
+        errors.push({ path: `${path3}.url_env`, code: "NOTIFICATION_WEBHOOK_URL_ENV_REQUIRED", message: "webhook url_env must name an environment variable." });
+      }
+      if (!isEnvName(rawSink.signing_secret_env)) {
+        errors.push({ path: `${path3}.signing_secret_env`, code: "NOTIFICATION_SIGNING_SECRET_ENV_REQUIRED", message: "webhook signing_secret_env must name an environment variable." });
+      }
+      if (rawSink.destination !== void 0) {
+        errors.push({ path: `${path3}.destination`, code: "WEBHOOK_DESTINATION_UNSUPPORTED", message: "webhook destinations come only from url_env." });
+      }
+    }
+    if (rawSink.type === "jsonl") {
+      if (rawSink.destination !== "stdout") {
+        errors.push({ path: `${path3}.destination`, code: "JSONL_STDOUT_REQUIRED", message: "the built-in JSONL development sink writes only to stdout." });
+      }
+      if (rawSink.url_env !== void 0 || rawSink.signing_secret_env !== void 0) {
+        errors.push({ path: path3, code: "JSONL_WEBHOOK_FIELDS_FORBIDDEN", message: "JSONL sinks do not accept webhook URL or signing-secret fields." });
+      }
+    }
+    if (rawSink.minimum_severity !== void 0 && !["informational", "warning", "critical"].includes(String(rawSink.minimum_severity))) {
+      errors.push({ path: `${path3}.minimum_severity`, code: "INVALID_NOTIFICATION_SEVERITY", message: "minimum_severity must be informational, warning, or critical." });
+    }
+    if (rawSink.delivery !== void 0 && !["immediate", "digest", "all"].includes(String(rawSink.delivery))) {
+      errors.push({ path: `${path3}.delivery`, code: "INVALID_NOTIFICATION_DELIVERY_MODE", message: "delivery must be immediate, digest, or all." });
+    }
+    if (rawSink.events !== void 0) {
+      if (!Array.isArray(rawSink.events) || rawSink.events.length > 64 || rawSink.events.some((event) => typeof event !== "string" || !NOTIFICATION_EVENT_TYPES.has(event))) {
+        errors.push({ path: `${path3}.events`, code: "INVALID_NOTIFICATION_EVENT_FILTER", message: "events must contain only supported fixed attention event names." });
+      }
+    }
+    if (rawSink.capabilities !== void 0 && (!Array.isArray(rawSink.capabilities) || rawSink.capabilities.length > 256 || rawSink.capabilities.some((item) => !isQualifiedName2(item)))) {
+      errors.push({ path: `${path3}.capabilities`, code: "INVALID_NOTIFICATION_CAPABILITY_FILTER", message: "capabilities must contain fixed qualified capability names." });
+    }
+    if (rawSink.environments !== void 0 && (!Array.isArray(rawSink.environments) || rawSink.environments.length > 4 || rawSink.environments.some((item) => !["development", "staging", "production", "unknown"].includes(String(item))))) {
+      errors.push({ path: `${path3}.environments`, code: "INVALID_NOTIFICATION_ENVIRONMENT_FILTER", message: "environments must contain development, staging, production, or unknown." });
+    }
+    for (const [key, minimum, maximum] of [
+      ["max_attempts", 1, 100],
+      ["timeout_ms", 100, 3e4],
+      ["max_response_bytes", 0, 65536],
+      ["replay_window_seconds", 30, 3600]
+    ]) {
+      if (rawSink[key] !== void 0 && (!Number.isSafeInteger(rawSink[key]) || Number(rawSink[key]) < minimum || Number(rawSink[key]) > maximum)) {
+        errors.push({ path: `${path3}.${key}`, code: "INVALID_NOTIFICATION_BOUND", message: `${key} must be an integer from ${minimum} through ${maximum}.` });
+      }
+    }
+    if (rawSink.allow_private_destinations !== void 0 && typeof rawSink.allow_private_destinations !== "boolean") {
+      errors.push({ path: `${path3}.allow_private_destinations`, code: "INVALID_PRIVATE_DESTINATION_POLICY", message: "allow_private_destinations must be boolean." });
+    }
+    if (rawSink.recovery_notifications !== void 0 && typeof rawSink.recovery_notifications !== "boolean") {
+      errors.push({ path: `${path3}.recovery_notifications`, code: "INVALID_RECOVERY_NOTIFICATION_POLICY", message: "recovery_notifications must be boolean." });
+    }
+    if (rawSink.private_host_allowlist !== void 0) {
+      if (!Array.isArray(rawSink.private_host_allowlist) || rawSink.private_host_allowlist.length > 32 || rawSink.private_host_allowlist.some((host) => !isSafeNotificationHost(host))) {
+        errors.push({ path: `${path3}.private_host_allowlist`, code: "INVALID_PRIVATE_HOST_ALLOWLIST", message: "private_host_allowlist must contain at most 32 fixed DNS hostnames or IP literals." });
+      }
+      if (rawSink.allow_private_destinations !== true && Array.isArray(rawSink.private_host_allowlist) && rawSink.private_host_allowlist.length > 0) {
+        errors.push({ path: `${path3}.allow_private_destinations`, code: "PRIVATE_DESTINATION_OPT_IN_REQUIRED", message: "private host exceptions require allow_private_destinations=true." });
+      }
+    }
+    validateNotificationBudgets(rawSink.budgets, `${path3}.budgets`, strict, errors);
+    validateNotificationQuietHours(rawSink.quiet_hours, `${path3}.quiet_hours`, strict, errors);
+  }
+}
+function validateNotificationBudgets(value, path3, strict, errors) {
+  if (value === void 0) return;
+  if (!isRecord2(value)) {
+    errors.push({ path: path3, code: "NOTIFICATION_BUDGETS_NOT_OBJECT", message: "notification budgets must be an object." });
+    return;
+  }
+  if (strict) checkUnknownKeys2(value, NOTIFICATION_BUDGET_KEYS, path3, errors);
+  for (const [key, minimum, maximum] of [
+    ["per_minute", 1, 1e4],
+    ["per_hour", 1, 1e5],
+    ["immediate_informational_per_hour", 0, 1e4],
+    ["aggregation_window_seconds", 1, 86400],
+    ["cooldown_seconds", 0, 604800],
+    ["max_unresolved_reminders", 0, 100],
+    ["digest_cadence_minutes", 1, 10080],
+    ["escalation_delay_seconds", 0, 604800],
+    ["retry_attempt_threshold", 1, 100],
+    ["degraded_duration_seconds", 1, 86400],
+    ["queue_depth_threshold", 1, 1e6],
+    ["queue_age_seconds", 1, 604800]
+  ]) {
+    if (value[key] !== void 0 && (!Number.isSafeInteger(value[key]) || Number(value[key]) < minimum || Number(value[key]) > maximum)) {
+      errors.push({ path: `${path3}.${key}`, code: "INVALID_NOTIFICATION_BUDGET", message: `${key} must be an integer from ${minimum} through ${maximum}.` });
+    }
+  }
+}
+function validateNotificationQuietHours(value, path3, strict, errors) {
+  if (value === void 0) return;
+  if (!isRecord2(value)) {
+    errors.push({ path: path3, code: "NOTIFICATION_QUIET_HOURS_NOT_OBJECT", message: "quiet_hours must be an object." });
+    return;
+  }
+  if (strict) checkUnknownKeys2(value, NOTIFICATION_QUIET_HOURS_KEYS, path3, errors);
+  for (const key of ["start_utc_hour", "end_utc_hour"]) {
+    if (!Number.isSafeInteger(value[key]) || Number(value[key]) < 0 || Number(value[key]) > 23) {
+      errors.push({ path: `${path3}.${key}`, code: "INVALID_NOTIFICATION_QUIET_HOUR", message: `${key} must be an integer from 0 through 23.` });
+    }
+  }
+}
+function validateSupervisedWorker(value, config, strict, errors) {
+  if (value === void 0) return;
+  if (!isRecord2(value)) {
+    errors.push({ path: "$.supervised_worker", code: "SUPERVISED_WORKER_NOT_OBJECT", message: "supervised_worker must be an explicit deployment policy object." });
+    return;
+  }
+  if (strict) checkUnknownKeys2(value, SUPERVISED_WORKER_KEYS, "$.supervised_worker", errors);
+  if (typeof value.enabled !== "boolean") {
+    errors.push({ path: "$.supervised_worker.enabled", code: "SUPERVISED_WORKER_ENABLED_REQUIRED", message: "supervised_worker.enabled must be an explicit boolean." });
+  }
+  if (value.profile !== "development" && value.profile !== "staging" && value.profile !== "production") {
+    errors.push({ path: "$.supervised_worker.profile", code: "SUPERVISED_WORKER_PROFILE_REQUIRED", message: "supervised_worker.profile must be development, staging, or production." });
+  }
+  if (!Array.isArray(value.capabilities)) {
+    errors.push({ path: "$.supervised_worker.capabilities", code: "SUPERVISED_WORKER_CAPABILITIES_REQUIRED", message: "supervised_worker.capabilities must be an explicit exact-digest allowlist." });
+    return;
+  }
+  if (value.enabled === true && value.capabilities.length === 0) {
+    errors.push({ path: "$.supervised_worker.capabilities", code: "SUPERVISED_WORKER_ALLOWLIST_REQUIRED", message: "enabled supervised-worker execution requires at least one exact capability/digest allowlist entry." });
+  }
+  if (config.mode !== "review" && value.enabled === true) {
+    errors.push({ path: "$.mode", code: "SUPERVISED_WORKER_REVIEW_MODE_REQUIRED", message: "supervised-worker execution requires Runner review mode." });
+  }
+  if (isRecord2(config.governance) && config.governance.mode === "cloud_linked" && value.enabled === true) {
+    errors.push({ path: "$.governance.mode", code: "SUPERVISED_WORKER_LOCAL_AUTHORITY_REQUIRED", message: "Cloud-linked governance does not permit the local supervised worker to become execution authority." });
+  }
+  if (value.profile === "production" && value.enabled === true) {
+    const operator = isRecord2(config.operator_identity) ? config.operator_identity : void 0;
+    if (!operator || operator.provider !== "signed_key" && operator.provider !== "jwt_oidc") {
+      errors.push({ path: "$.operator_identity.provider", code: "SUPERVISED_WORKER_VERIFIED_OPERATOR_REQUIRED", message: "production supervised-worker controls require signed_key or jwt_oidc operator identity." });
+    }
+  }
+  const runtimeCapabilities = Array.isArray(config.capabilities) ? config.capabilities.filter(isRecord2) : [];
+  const byName = new Map(runtimeCapabilities.flatMap((capability) => isQualifiedName2(capability.name) ? [[String(capability.name), capability]] : []));
+  const sources = isRecord2(config.sources) ? config.sources : {};
+  const notifications = isRecord2(config.notifications) ? config.notifications : void 0;
+  const notificationSinks = new Map(
+    Array.isArray(notifications?.sinks) ? notifications.sinks.filter(isRecord2).filter((sink) => isSafeName(sink.id)).map((sink) => [String(sink.id), sink]) : []
+  );
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, rawEntry] of value.capabilities.entries()) {
+    const path3 = `$.supervised_worker.capabilities[${index}]`;
+    if (!isRecord2(rawEntry)) {
+      errors.push({ path: path3, code: "SUPERVISED_WORKER_CAPABILITY_NOT_OBJECT", message: "each supervised-worker allowlist entry must be an object." });
+      continue;
+    }
+    if (strict) checkUnknownKeys2(rawEntry, SUPERVISED_WORKER_CAPABILITY_KEYS, path3, errors);
+    if (!isQualifiedName2(rawEntry.capability)) {
+      errors.push({ path: `${path3}.capability`, code: "INVALID_SUPERVISED_WORKER_CAPABILITY", message: "capability must be a fixed qualified capability name." });
+    }
+    if (typeof rawEntry.contract_digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(rawEntry.contract_digest)) {
+      errors.push({ path: `${path3}.contract_digest`, code: "INVALID_SUPERVISED_WORKER_DIGEST", message: "contract_digest must be the exact canonical sha256 digest." });
+    }
+    if (rawEntry.mode !== "supervised_worker") {
+      errors.push({ path: `${path3}.mode`, code: "INVALID_SUPERVISED_WORKER_MODE", message: "mode must be supervised_worker." });
+    }
+    for (const [key2, minimum, maximum] of [
+      ["concurrency", 1, 32],
+      ["queue_limit", 1, 1e4],
+      ["lease_seconds", 15, 3600],
+      ["max_attempts", 1, 100],
+      ["proposal_ttl_seconds", 60, 2592e3]
+    ]) {
+      if (!Number.isSafeInteger(rawEntry[key2]) || Number(rawEntry[key2]) < minimum || Number(rawEntry[key2]) > maximum) {
+        errors.push({ path: `${path3}.${key2}`, code: "INVALID_SUPERVISED_WORKER_BOUND", message: `${key2} must be an integer from ${minimum} through ${maximum}.` });
+      }
+    }
+    if (!isEnvName(rawEntry.write_url_env)) {
+      errors.push({ path: `${path3}.write_url_env`, code: "SUPERVISED_WORKER_WRITE_ENV_REQUIRED", message: "write_url_env must name the separately configured writer credential environment variable." });
+    }
+    if (rawEntry.require_least_privilege_writer !== void 0 && typeof rawEntry.require_least_privilege_writer !== "boolean") {
+      errors.push({ path: `${path3}.require_least_privilege_writer`, code: "INVALID_SUPERVISED_WORKER_POSTURE_MODE", message: "require_least_privilege_writer must be an explicit boolean when present." });
+    }
+    if (rawEntry.writer_posture_fingerprint !== void 0 && (typeof rawEntry.writer_posture_fingerprint !== "string" || !/^sha256:[a-f0-9]{64}$/.test(rawEntry.writer_posture_fingerprint))) {
+      errors.push({ path: `${path3}.writer_posture_fingerprint`, code: "INVALID_SUPERVISED_WORKER_POSTURE_FINGERPRINT", message: "writer_posture_fingerprint must be the reviewed non-secret sha256 posture digest." });
+    }
+    if (rawEntry.require_least_privilege_writer === true && rawEntry.writer_posture_fingerprint === void 0) {
+      errors.push({ path: `${path3}.writer_posture_fingerprint`, code: "SUPERVISED_WORKER_POSTURE_FINGERPRINT_REQUIRED", message: "hardened writer posture requires an exact reviewed posture fingerprint." });
+    }
+    if (value.enabled === true && value.profile === "production" && (rawEntry.require_least_privilege_writer !== true || rawEntry.writer_posture_fingerprint === void 0)) {
+      errors.push({ path: path3, code: "SUPERVISED_WORKER_PRODUCTION_POSTURE_REQUIRED", message: "production supervised execution requires live least-privilege writer verification bound to an exact reviewed posture fingerprint." });
+    }
+    if (rawEntry.worker_identity !== void 0 && !isSafeName(rawEntry.worker_identity)) {
+      errors.push({ path: `${path3}.worker_identity`, code: "INVALID_SUPERVISED_WORKER_IDENTITY", message: "worker_identity must be a fixed safe operator identity." });
+    }
+    if (rawEntry.control_role !== void 0 && !isSafeName(rawEntry.control_role)) {
+      errors.push({ path: `${path3}.control_role`, code: "INVALID_SUPERVISED_WORKER_CONTROL_ROLE", message: "control_role must be a fixed safe operator role." });
+    }
+    if (rawEntry.required_attention_sinks !== void 0) {
+      if (!Array.isArray(rawEntry.required_attention_sinks) || rawEntry.required_attention_sinks.length < 1 || rawEntry.required_attention_sinks.length > 8 || rawEntry.required_attention_sinks.some((sink) => !isSafeName(sink))) {
+        errors.push({ path: `${path3}.required_attention_sinks`, code: "INVALID_REQUIRED_ATTENTION_SINKS", message: "required_attention_sinks must contain 1 through 8 fixed sink ids." });
+      } else {
+        if (notifications?.enabled !== true) {
+          errors.push({ path: "$.notifications.enabled", code: "HEALTH_GATE_NOTIFICATIONS_REQUIRED", message: "required attention sinks need notifications.enabled=true." });
+        }
+        for (const [sinkIndex, sinkId] of rawEntry.required_attention_sinks.entries()) {
+          const sink = notificationSinks.get(String(sinkId));
+          if (!sink || sink.enabled === false) {
+            errors.push({ path: `${path3}.required_attention_sinks[${sinkIndex}]`, code: "REQUIRED_ATTENTION_SINK_UNAVAILABLE", message: `required attention sink ${String(sinkId)} must name an enabled configured sink.` });
+          }
+        }
+      }
+    }
+    if (!isRecord2(rawEntry.rate_limit)) {
+      errors.push({ path: `${path3}.rate_limit`, code: "SUPERVISED_WORKER_RATE_LIMIT_REQUIRED", message: "rate_limit must define a bounded execution window." });
+    } else {
+      if (strict) checkUnknownKeys2(rawEntry.rate_limit, SUPERVISED_WORKER_RATE_LIMIT_KEYS, `${path3}.rate_limit`, errors);
+      if (!Number.isSafeInteger(rawEntry.rate_limit.executions) || Number(rawEntry.rate_limit.executions) < 1 || Number(rawEntry.rate_limit.executions) > 1e5) {
+        errors.push({ path: `${path3}.rate_limit.executions`, code: "INVALID_SUPERVISED_WORKER_RATE", message: "rate_limit.executions must be an integer from 1 through 100000." });
+      }
+      if (!Number.isSafeInteger(rawEntry.rate_limit.window_seconds) || Number(rawEntry.rate_limit.window_seconds) < 1 || Number(rawEntry.rate_limit.window_seconds) > 86400) {
+        errors.push({ path: `${path3}.rate_limit.window_seconds`, code: "INVALID_SUPERVISED_WORKER_WINDOW", message: "rate_limit.window_seconds must be an integer from 1 through 86400." });
+      }
+    }
+    const key = `${String(rawEntry.capability)}:${String(rawEntry.contract_digest)}`;
+    if (seen.has(key)) {
+      errors.push({ path: path3, code: "DUPLICATE_SUPERVISED_WORKER_ALLOWLIST", message: "each capability/digest may appear only once." });
+    }
+    seen.add(key);
+    const capability = byName.get(String(rawEntry.capability));
+    if (!capability) {
+      if (runtimeCapabilities.length > 0 || !Array.isArray(config.contracts)) {
+        errors.push({ path: `${path3}.capability`, code: "SUPERVISED_WORKER_CAPABILITY_UNKNOWN", message: "allowlist capability must resolve from the active Runner contract catalog." });
+      }
+      continue;
+    }
+    const provenance = isRecord2(capability.contract_provenance) ? capability.contract_provenance : void 0;
+    if (!provenance || provenance.digest !== rawEntry.contract_digest) {
+      errors.push({ path: `${path3}.contract_digest`, code: "SUPERVISED_WORKER_DIGEST_MISMATCH", message: "allowlist digest must exactly match the active capability contract digest." });
+    }
+    if (!isRecord2(capability.execution) || capability.execution.supervised_worker !== "allowed") {
+      errors.push({ path: `${path3}.capability`, code: "SUPERVISED_WORKER_CONTRACT_PERMISSION_REQUIRED", message: "the active capability contract does not permit supervised-worker execution." });
+    }
+    const source = isNonEmptyString2(capability.source) && isRecord2(sources[capability.source]) ? sources[capability.source] : void 0;
+    if (!source || source.write_url_env !== rawEntry.write_url_env || source.read_only === true) {
+      errors.push({ path: `${path3}.write_url_env`, code: "SUPERVISED_WORKER_WRITER_MISMATCH", message: "allowlist write_url_env must match the selected writable source without embedding a credential." });
+    }
+    if (!source || !isRecord2(source.receipts)) {
+      errors.push({ path: `$.sources.${String(capability.source)}.receipts`, code: "SUPERVISED_WORKER_RECEIPT_AUTHORITY_REQUIRED", message: "supervised-worker execution requires explicit source_db or runner_ledger receipt authority." });
+    }
+    if (rawEntry.require_least_privilege_writer === true && source && isRecord2(source.receipts) && source.receipts.authority === "source_db" && (source.receipts.provisioning !== "precreated" || !isSafeIdentifier2(source.receipts.schema) || !isSafeIdentifier2(source.receipts.table))) {
+      errors.push({
+        path: `$.sources.${String(capability.source)}.receipts`,
+        code: "SUPERVISED_WORKER_PRECREATED_RECEIPT_REQUIRED",
+        message: "hardened supervised execution with source_db receipts requires an explicitly named precreated receipt table; the runtime writer must not retain schema-creation authority."
+      });
+    }
+    if (!isRecord2(capability.target) || !isSafeIdentifier2(capability.target.tenant_key)) {
+      errors.push({ path: `${path3}.capability`, code: "SUPERVISED_WORKER_TENANT_SCOPE_REQUIRED", message: "supervised-worker execution requires a trusted tenant-scoped target." });
+    }
+    const operation = isRecord2(capability.operation) ? capability.operation : { kind: "update" };
+    const operationKind = operation.kind ?? "update";
+    if (operation.cardinality === "set" || operationKind === "delete" || capability.reversibility !== void 0 || !isRecord2(capability.writeback) || capability.writeback.mode !== "direct_sql") {
+      errors.push({ path: `${path3}.capability`, code: "SUPERVISED_WORKER_SHAPE_INELIGIBLE", message: "the first supervised-worker release permits only native single-row direct_sql UPDATE/INSERT without compensation." });
+    }
+    if (operationKind === "update" && (!isRecord2(capability.conflict_guard) || !isSafeIdentifier2(capability.conflict_guard.column) || capability.conflict_guard.weak_guard_ack === true)) {
+      errors.push({ path: `${path3}.capability`, code: "SUPERVISED_WORKER_EXACT_GUARD_REQUIRED", message: "supervised-worker UPDATE requires an exact version/conflict guard." });
+    }
+    if (operationKind === "insert" && !isRecord2(operation.deduplication)) {
+      errors.push({ path: `${path3}.capability`, code: "SUPERVISED_WORKER_INSERT_DEDUP_REQUIRED", message: "supervised-worker INSERT requires reviewed deterministic source deduplication." });
+    }
+  }
+}
 function validateHttpSecurity(value, sessionAuth, trustedContext, contexts, strict, errors, warnings) {
   if (value === void 0) return;
   if (!isRecord2(value)) {
@@ -2314,9 +2776,9 @@ function validateRateLimits(value, strict, errors) {
     if (!isRecord2(value.capabilities)) {
       errors.push({ path: "$.rate_limits.capabilities", code: "RATE_LIMIT_CAPABILITIES_NOT_OBJECT", message: "capabilities must map reviewed capability names to rate-limit rules." });
     } else {
-      for (const [name, rule] of Object.entries(value.capabilities)) {
+      for (const [name, rule2] of Object.entries(value.capabilities)) {
         if (!isQualifiedName2(name)) errors.push({ path: `$.rate_limits.capabilities.${name}`, code: "INVALID_RATE_LIMIT_CAPABILITY", message: "rate-limit capability keys must be qualified capability names." });
-        validateRateLimitRule(rule, `$.rate_limits.capabilities.${name}`, strict, errors);
+        validateRateLimitRule(rule2, `$.rate_limits.capabilities.${name}`, strict, errors);
       }
     }
   }
@@ -2896,7 +3358,7 @@ function validatePolicies2(value, strict, errors) {
       if (!Array.isArray(policy.rules)) {
         errors.push({ path: `${path3}.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, `${path3}.rules[${ruleIndex}]`, strict, errors));
+        policy.rules.forEach((rule2, ruleIndex) => validateApprovalPolicyRule(rule2, `${path3}.rules[${ruleIndex}]`, strict, errors));
       }
     }
     if (policy.limits !== void 0) {
@@ -3087,10 +3549,20 @@ function validateExecutorAuth(value, path3, strict, errors) {
     errors.push({ path: `${path3}.token_env`, code: "EXECUTOR_TOKEN_ENV_REQUIRED", message: "bearer_env auth requires token_env." });
   }
 }
-function validateCapabilities2(value, sources, contexts, executors, mode, strict, errors, warnings, hasContracts = false) {
+function validateCapabilities2(value, sources, contexts, executors, mode, strict, errors, warnings, hasContracts = false, generatedAuthority) {
   if (mode === "cloud" && value === void 0) return;
   if (hasContracts && value === void 0) return;
   if (hasContracts && Array.isArray(value) && value.length === 0) return;
+  const emptyReadOnlyShell = mode === "read_only" && Array.isArray(value) && value.length === 0;
+  if (emptyReadOnlyShell) {
+    const lockBound = isRecord2(generatedAuthority) && generatedAuthority.enforcement === "required";
+    warnings.push({
+      path: "$.capabilities",
+      code: lockBound ? "AUTHORING_PROJECT_HAS_NO_ACTIVE_CAPABILITIES" : "READ_ONLY_CONFIG_HAS_NO_ACTIVE_CAPABILITIES",
+      message: lockBound ? "This generated authoring project exposes no named runtime capabilities until an exact reviewed digest is activated." : "This read-only configuration exposes no model-facing capabilities."
+    });
+    return;
+  }
   if (!Array.isArray(value) || value.length === 0) {
     errors.push({ path: "$.capabilities", code: "CAPABILITIES_REQUIRED", message: "At least one capability is required." });
     return;
@@ -3622,6 +4094,16 @@ function validateProposalCapability(capability, path3, strict, errors) {
       }
     }
   }
+  if (capability.execution !== void 0) {
+    if (!isRecord2(capability.execution)) {
+      errors.push({ path: `${path3}.execution`, code: "EXECUTION_NOT_OBJECT", message: "execution must be an explicit reviewed permission object." });
+    } else {
+      if (strict) checkUnknownKeys2(capability.execution, EXECUTION_KEYS2, `${path3}.execution`, errors);
+      if (capability.execution.supervised_worker !== "allowed") {
+        errors.push({ path: `${path3}.execution.supervised_worker`, code: "INVALID_SUPERVISED_WORKER_PERMISSION", message: "execution.supervised_worker must be allowed when present." });
+      }
+    }
+  }
   if (operation === "delete" && capabilityWritebackMode(capability) === "direct_sql") {
     const approval = isRecord2(capability.approval) ? capability.approval : void 0;
     if (!approval || approval.mode !== "human" && approval.mode !== "operator") {
@@ -3896,6 +4378,10 @@ function isSafeIdentifier2(value) {
 function isSafeName(value) {
   return typeof value === "string" && /^[A-Za-z_][A-Za-z0-9_.-]*$/.test(value);
 }
+function isSafeNotificationHost(value) {
+  if (typeof value !== "string" || value.length < 1 || value.length > 253 || /[\s/@?#]/.test(value)) return false;
+  return /^[A-Za-z0-9.-]+$/.test(value) || /^[0-9A-Fa-f:]+$/.test(value);
+}
 function isQualifiedName2(value) {
   return typeof value === "string" && /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/.test(value);
 }
@@ -5979,6 +6465,90 @@ var PostgresProposalRuntimeStore = class {
   async requireWritebackReconciliation(intentId, reason) {
     await this.withWrite("requireWritebackReconciliation", (store) => store.requireWritebackReconciliation(intentId, reason));
   }
+  async enqueueWorkerProposal(input) {
+    return await this.withWrite("enqueueWorkerProposal", (store) => store.enqueueWorkerProposal(input));
+  }
+  async claimWorkerItem(input) {
+    return await this.withWrite("claimWorkerItem", (store) => store.claimWorkerItem(input));
+  }
+  async assertActiveWorkerLease(input) {
+    return await this.withRead((store) => store.assertActiveWorkerLease(input));
+  }
+  async renewWorkerLease(input) {
+    return await this.withWrite("renewWorkerLease", (store) => store.renewWorkerLease(input));
+  }
+  async completeWorkerItem(proposalId, workerId, outcome, now, leaseId) {
+    return await this.withWrite("completeWorkerItem", (store) => store.completeWorkerItem(proposalId, workerId, outcome, now, leaseId));
+  }
+  async blockWorkerItem(input) {
+    return await this.withWrite("blockWorkerItem", (store) => store.blockWorkerItem(input));
+  }
+  async requireWorkerReconciliation(input) {
+    return await this.withWrite("requireWorkerReconciliation", (store) => store.requireWorkerReconciliation(input));
+  }
+  async workerControlState() {
+    return await this.withRead((store) => store.workerControlState());
+  }
+  async updateWorkerControl(input) {
+    return await this.withWrite("updateWorkerControl", (store) => store.updateWorkerControl(input));
+  }
+  async cancelWorkerItem(input) {
+    return await this.withWrite("cancelWorkerItem", (store) => store.cancelWorkerItem(input));
+  }
+  async listWorkerQueue(status) {
+    return await this.withRead((store) => store.listWorkerQueue(status));
+  }
+  async getWorkerQueueItem(proposalId) {
+    return await this.withRead((store) => store.getWorkerQueueItem(proposalId));
+  }
+  async recordAttentionEvent(input) {
+    return await this.withWrite("recordAttentionEvent", (store) => store.recordAttentionEvent(input));
+  }
+  async listAttentionEvents(filters = {}) {
+    return await this.withRead((store) => store.listAttentionEvents(filters));
+  }
+  async getAttentionEvent(eventId) {
+    return await this.withRead((store) => store.getAttentionEvent(eventId));
+  }
+  async listAttentionItems(filters = {}) {
+    return await this.withRead((store) => store.listAttentionItems(filters));
+  }
+  async getAttentionItem(attentionId) {
+    return await this.withRead((store) => store.getAttentionItem(attentionId));
+  }
+  async acknowledgeAttention(input) {
+    return await this.withWrite("acknowledgeAttention", (store) => store.acknowledgeAttention(input));
+  }
+  async resolveAttention(input) {
+    return await this.withWrite("resolveAttention", (store) => store.resolveAttention(input));
+  }
+  async enqueueNotificationDelivery(input) {
+    return await this.withWrite("enqueueNotificationDelivery", (store) => store.enqueueNotificationDelivery(input));
+  }
+  async includeNotificationDeliveriesInDigest(input) {
+    return await this.withWrite(
+      "includeNotificationDeliveriesInDigest",
+      (store) => store.includeNotificationDeliveriesInDigest(input)
+    );
+  }
+  async claimNotificationDeliveries(input) {
+    return await this.withWrite("claimNotificationDeliveries", (store) => store.claimNotificationDeliveries(input));
+  }
+  async completeNotificationDelivery(input) {
+    return await this.withWrite("completeNotificationDelivery", (store) => store.completeNotificationDelivery(input));
+  }
+  async failNotificationDelivery(input) {
+    return await this.withWrite("failNotificationDelivery", (store) => store.failNotificationDelivery(input));
+  }
+  async listNotificationDeliveries(filters = {}) {
+    return await this.withRead((store) => store.listNotificationDeliveries(filters));
+  }
+  async getNotificationDelivery(deliveryId) {
+    return await this.withRead((store) => store.getNotificationDelivery(deliveryId));
+  }
+  async requeueNotificationDelivery(input) {
+    return await this.withWrite("requeueNotificationDelivery", (store) => store.requeueNotificationDelivery(input));
+  }
   async enqueueCloudOutbox(input) {
     return await this.withWrite("enqueueCloudOutbox", (store) => store.enqueueCloudOutbox(input));
   }
@@ -6236,6 +6806,9 @@ var ProposalStore = class {
       shadow_study_cases: this.countTable("shadow_study_cases"),
       shadow_outcomes: this.countTable("shadow_outcomes"),
       worker_queue: this.countTable("worker_queue"),
+      attention_events: this.countTable("attention_events"),
+      attention_items: this.countTable("attention_items"),
+      notification_deliveries: this.countTable("notification_deliveries"),
       policy_recommendations: this.countTable("policy_recommendations"),
       page_count: pageCount,
       page_size: pageSize,
@@ -6575,15 +7148,95 @@ var ProposalStore = class {
         updated_at TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS attention_events (
+        event_id TEXT PRIMARY KEY,
+        schema_version TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        severity TEXT NOT NULL,
+        occurred_at TEXT NOT NULL,
+        environment TEXT NOT NULL,
+        proposal_id TEXT,
+        job_id TEXT,
+        operation_id TEXT,
+        correlation_id TEXT,
+        capability TEXT,
+        contract_digest TEXT,
+        attention_key TEXT,
+        attention_required INTEGER NOT NULL,
+        immediate_default INTEGER NOT NULL,
+        summary TEXT NOT NULL,
+        approval_source TEXT,
+        worker_state TEXT,
+        failure_class TEXT,
+        expires_at TEXT,
+        workbench_path TEXT,
+        details_json TEXT NOT NULL,
+        payload_hash TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS attention_items (
+        attention_id TEXT PRIMARY KEY,
+        attention_key TEXT NOT NULL UNIQUE,
+        status TEXT NOT NULL,
+        severity TEXT NOT NULL,
+        environment TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        capability TEXT,
+        contract_digest TEXT,
+        title TEXT NOT NULL,
+        occurrence_count INTEGER NOT NULL,
+        first_event_id TEXT NOT NULL,
+        latest_event_id TEXT NOT NULL,
+        first_seen_at TEXT NOT NULL,
+        last_seen_at TEXT NOT NULL,
+        acknowledged_by TEXT,
+        acknowledged_at TEXT,
+        acknowledgement_identity_json TEXT,
+        acknowledgement_decision_hash TEXT,
+        acknowledgement_signature TEXT,
+        acknowledgement_integrity_hash TEXT,
+        resolved_at TEXT,
+        expires_at TEXT,
+        FOREIGN KEY (first_event_id) REFERENCES attention_events(event_id),
+        FOREIGN KEY (latest_event_id) REFERENCES attention_events(event_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS notification_deliveries (
+        delivery_id TEXT PRIMARY KEY,
+        sink_id TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        attention_id TEXT,
+        status TEXT NOT NULL,
+        attempts INTEGER NOT NULL DEFAULT 0,
+        max_attempts INTEGER NOT NULL,
+        next_attempt_at TEXT NOT NULL,
+        lease_owner TEXT,
+        lease_id TEXT,
+        lease_expires_at TEXT,
+        last_error_code TEXT,
+        external_reference TEXT,
+        delivered_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(sink_id, event_id),
+        FOREIGN KEY (event_id) REFERENCES attention_events(event_id),
+        FOREIGN KEY (attention_id) REFERENCES attention_items(attention_id)
+      );
+
       CREATE TABLE IF NOT EXISTS worker_queue (
         proposal_id TEXT PRIMARY KEY,
         status TEXT NOT NULL,
+        execution_mode TEXT DEFAULT 'legacy',
+        contract_digest TEXT,
         attempts INTEGER NOT NULL DEFAULT 0,
         max_attempts INTEGER NOT NULL,
         next_attempt_at TEXT NOT NULL,
         lease_owner TEXT,
+        lease_id TEXT,
         lease_expires_at TEXT,
         last_error_code TEXT,
+        terminal_outcome TEXT,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
         FOREIGN KEY (proposal_id) REFERENCES proposals(proposal_id)
@@ -6605,6 +7258,12 @@ var ProposalStore = class {
       CREATE INDEX IF NOT EXISTS idx_cloud_outbox_due ON cloud_outbox(status, next_attempt_at, sequence, created_at);
       CREATE INDEX IF NOT EXISTS idx_cloud_outbox_proposal ON cloud_outbox(proposal_id, sequence, created_at);
       CREATE INDEX IF NOT EXISTS idx_cloud_governance_proposal ON cloud_governance_events(proposal_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_attention_events_type_time ON attention_events(event_type, occurred_at, event_id);
+      CREATE INDEX IF NOT EXISTS idx_attention_events_proposal ON attention_events(proposal_id, occurred_at, event_id);
+      CREATE INDEX IF NOT EXISTS idx_attention_events_capability ON attention_events(capability, occurred_at, event_id);
+      CREATE INDEX IF NOT EXISTS idx_attention_items_status ON attention_items(status, severity, last_seen_at, attention_id);
+      CREATE INDEX IF NOT EXISTS idx_notification_deliveries_due ON notification_deliveries(status, next_attempt_at, created_at, delivery_id);
+      CREATE INDEX IF NOT EXISTS idx_notification_deliveries_sink ON notification_deliveries(sink_id, status, updated_at, delivery_id);
 
       INSERT OR IGNORE INTO proposal_store_schema(version, applied_at)
       VALUES (1, datetime('now'));
@@ -6636,6 +7295,14 @@ var ProposalStore = class {
     this.ensureColumn("approvals", "signature", "TEXT");
     this.ensureColumn("approvals", "integrity_hash", "TEXT");
     this.ensureColumn("approvals", "freshness_proof_digest", "TEXT");
+    this.ensureColumn("attention_items", "acknowledgement_identity_json", "TEXT");
+    this.ensureColumn("attention_items", "acknowledgement_decision_hash", "TEXT");
+    this.ensureColumn("attention_items", "acknowledgement_signature", "TEXT");
+    this.ensureColumn("attention_items", "acknowledgement_integrity_hash", "TEXT");
+    this.ensureColumn("worker_queue", "execution_mode", "TEXT DEFAULT 'legacy'");
+    this.ensureColumn("worker_queue", "contract_digest", "TEXT");
+    this.ensureColumn("worker_queue", "lease_id", "TEXT");
+    this.ensureColumn("worker_queue", "terminal_outcome", "TEXT");
   }
   ensureSearchIndexes() {
     this.db.exec(`
@@ -6679,6 +7346,7 @@ var ProposalStore = class {
 
       CREATE INDEX IF NOT EXISTS idx_proposal_events_kind_created ON proposal_events(kind, created_at);
       CREATE INDEX IF NOT EXISTS idx_worker_queue_claim ON worker_queue(status, next_attempt_at, lease_expires_at, created_at);
+      CREATE INDEX IF NOT EXISTS idx_worker_queue_supervised_claim ON worker_queue(execution_mode, contract_digest, status, next_attempt_at, lease_expires_at, created_at);
     `);
   }
   ensureColumn(table, column, definition) {
@@ -7058,6 +7726,7 @@ var ProposalStore = class {
     const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
     const window2 = utcDayWindow(now);
     const trippedLimits = [];
+    const nearLimits = [];
     let quorumDeferred = false;
     this.transaction(() => {
       const proposal = this.requireProposal(proposalId);
@@ -7110,6 +7779,17 @@ var ProposalStore = class {
               window_end: window2.end,
               reason: `${scope} daily auto-approval count ${projected2} exceeds ${limit.max}`
             });
+          } else if (projected2 / limit.max >= 0.8) {
+            nearLimits.push({
+              ...limit,
+              scope,
+              observed: rows.length,
+              proposed: 1,
+              projected: projected2,
+              window_start: window2.start,
+              window_end: window2.end,
+              reason: `${scope} daily auto-approval count ${projected2} is approaching ${limit.max}`
+            });
           }
           continue;
         }
@@ -7144,6 +7824,17 @@ var ProposalStore = class {
             window_end: window2.end,
             reason: invalidHistory || !field || typeof proposed !== "number" || !Number.isSafeInteger(proposed) ? `${scope} daily auto-approval total could not be verified safely${field ? ` for ${field}` : ""}` : `${scope} daily auto-approval total ${projected} for ${field} exceeds ${limit.max}`
           });
+        } else if (projected / limit.max >= 0.8) {
+          nearLimits.push({
+            ...limit,
+            scope,
+            observed,
+            proposed: proposedNumber,
+            projected,
+            window_start: window2.start,
+            window_end: window2.end,
+            reason: `${scope} daily auto-approval total is approaching its reviewed maximum`
+          });
         }
       }
       if (trippedLimits.length > 0) {
@@ -7180,6 +7871,19 @@ var ProposalStore = class {
         aggregate_limits: options.limits ?? [],
         freshness_proof_digest: options.freshness_proof_digest ?? null
       });
+      for (const near of nearLimits) {
+        this.appendEvent(proposalId, "policy_limit_near", actor, {
+          policy: options.policy,
+          kind: near.kind,
+          scope: near.scope,
+          observed: near.observed,
+          proposed: near.proposed,
+          projected: near.projected,
+          max: near.max,
+          window_start: near.window_start,
+          window_end: near.window_end
+        });
+      }
     });
     return {
       proposal: this.requireProposal(proposalId),
@@ -7489,6 +8193,30 @@ var ProposalStore = class {
         decision_hash: input.identity?.decision_hash
       });
       this.recordExecutionReceiptRows(receipt, proposal);
+      const workerItem = this.workerQueueItem(intent.proposal_id);
+      if (workerItem?.status === "reconciliation_required") {
+        const queueStatus = receipt.status === "failed" ? "dead_letter" : "completed";
+        const terminalOutcome = receipt.status === "failed" ? "dead_letter" : receipt.status;
+        this.db.prepare(`
+          UPDATE worker_queue
+          SET status = ?, lease_owner = NULL, lease_id = NULL,
+              lease_expires_at = NULL, last_error_code = ?,
+              terminal_outcome = ?, updated_at = ?
+          WHERE proposal_id = ? AND status = 'reconciliation_required'
+        `).run(
+          queueStatus,
+          receipt.status === "failed" ? "RECONCILED_FAILED" : null,
+          terminalOutcome,
+          receipt.executed_at,
+          intent.proposal_id
+        );
+        this.appendEvent(intent.proposal_id, "writeback_worker_reconciled", input.actor, {
+          intent_id: intent.intent_id,
+          outcome: receipt.status,
+          queue_status: queueStatus,
+          source_database_changed: false
+        });
+      }
     });
     return this.requireWritebackIntent(intent.intent_id);
   }
@@ -7817,6 +8545,78 @@ var ProposalStore = class {
     const rows = this.db.prepare(query.sql).all(...query.params);
     return rows.map(rowToEvent).filter((event) => event !== void 0);
   }
+  enqueueWorkerProposal(options) {
+    const proposal = this.requireProposal(options.proposal_id);
+    if (proposal.state !== "approved" && proposal.state !== "pending_worker") {
+      throw new ProposalStoreError(
+        "WORKER_PROPOSAL_NOT_APPROVED",
+        `proposal ${proposal.proposal_id} is ${proposal.state}, not approved for worker execution`
+      );
+    }
+    const executionMode = options.execution_mode ?? "legacy";
+    const contractDigest = options.contract_digest;
+    if (executionMode === "supervised_worker" && !contractDigest) {
+      throw new ProposalStoreError(
+        "SUPERVISED_WORKER_DIGEST_REQUIRED",
+        `supervised worker queue item ${proposal.proposal_id} requires an exact contract digest`
+      );
+    }
+    if (contractDigest && !/^sha256:[a-f0-9]{64}$/.test(contractDigest)) {
+      throw new ProposalStoreError("WORKER_CONTRACT_DIGEST_INVALID", "worker queue contract digest must be a full lowercase sha256 digest");
+    }
+    const maxAttempts = Math.max(1, Math.min(options.max_attempts ?? 5, 100));
+    const queueLimit = Math.max(1, Math.min(options.queue_limit ?? 1e4, 1e5));
+    const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.transaction(() => {
+      const existing = this.workerQueueItem(proposal.proposal_id);
+      if (existing) {
+        if (existing.execution_mode !== executionMode || existing.contract_digest !== contractDigest) {
+          throw new ProposalStoreError(
+            "WORKER_QUEUE_AUTHORITY_MISMATCH",
+            `worker queue item ${proposal.proposal_id} already exists under different execution authority`
+          );
+        }
+        return;
+      }
+      const active = this.db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM worker_queue q
+        JOIN proposals p ON p.proposal_id = q.proposal_id
+        WHERE q.execution_mode = ?
+          AND (? IS NULL OR q.contract_digest = ?)
+          AND p.action = ?
+          AND q.status IN ('queued', 'leased', 'retry_wait', 'blocked', 'reconciliation_required')
+      `).get(executionMode, contractDigest ?? null, contractDigest ?? null, proposal.action);
+      if (isRecord3(active) && Number(active.count ?? 0) >= queueLimit) {
+        throw new ProposalStoreError(
+          "WORKER_QUEUE_LIMIT_EXCEEDED",
+          `worker queue limit ${queueLimit} reached for ${proposal.action}`
+        );
+      }
+      this.db.prepare(`
+        INSERT INTO worker_queue (
+          proposal_id, status, execution_mode, contract_digest, attempts,
+          max_attempts, next_attempt_at, lease_owner, lease_id,
+          lease_expires_at, last_error_code, terminal_outcome, created_at,
+          updated_at
+        ) VALUES (?, 'queued', ?, ?, 0, ?, ?, NULL, NULL, NULL, NULL, NULL, ?, ?)
+      `).run(
+        proposal.proposal_id,
+        executionMode,
+        contractDigest ?? null,
+        maxAttempts,
+        now,
+        now,
+        now
+      );
+      this.appendEvent(proposal.proposal_id, "writeback_worker_queued", "runner", {
+        execution_mode: executionMode,
+        contract_digest: contractDigest ?? null,
+        max_attempts: maxAttempts
+      });
+    });
+    return this.requireWorkerQueueItem(proposal.proposal_id);
+  }
   enqueueApprovedForWorker(options = {}) {
     const maxAttempts = Math.max(1, Math.min(options.maxAttempts ?? 5, 100));
     const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
@@ -7828,9 +8628,11 @@ var ProposalStore = class {
       for (const proposal of proposals) {
         this.db.prepare(`
           INSERT OR IGNORE INTO worker_queue (
-            proposal_id, status, attempts, max_attempts, next_attempt_at,
-            lease_owner, lease_expires_at, last_error_code, created_at, updated_at
-          ) VALUES (?, 'queued', 0, ?, ?, NULL, NULL, NULL, ?, ?)
+            proposal_id, status, execution_mode, contract_digest, attempts,
+            max_attempts, next_attempt_at, lease_owner, lease_id,
+            lease_expires_at, last_error_code, terminal_outcome, created_at,
+            updated_at
+          ) VALUES (?, 'queued', 'legacy', NULL, 0, ?, ?, NULL, NULL, NULL, NULL, NULL, ?, ?)
         `).run(proposal.proposal_id, maxAttempts, now, now, now);
       }
     });
@@ -7842,67 +8644,358 @@ var ProposalStore = class {
     const leaseExpiresAt = new Date(Date.parse(now) + leaseSeconds * 1e3).toISOString();
     let claimed;
     this.transaction(() => {
-      const raw = this.db.prepare(`
-        SELECT q.*
-        FROM worker_queue q
+      if (options.maxConcurrent !== void 0) {
+        const maximum = Math.max(1, Math.min(options.maxConcurrent, 32));
+        const active = this.db.prepare(`
+          SELECT COUNT(*) AS count
+          FROM worker_queue q
+          JOIN proposals p ON p.proposal_id = q.proposal_id
+          WHERE q.status = 'leased'
+            AND q.lease_expires_at > ?
+            AND (? IS NULL OR q.execution_mode = ?)
+            AND (? IS NULL OR p.action = ?)
+            AND (? IS NULL OR p.tenant_id = ?)
+            AND (? IS NULL OR q.contract_digest = ?)
+        `).get(
+          now,
+          options.executionMode ?? null,
+          options.executionMode ?? null,
+          options.capability ?? null,
+          options.capability ?? null,
+          options.tenant ?? null,
+          options.tenant ?? null,
+          options.contractDigest ?? null,
+          options.contractDigest ?? null
+        );
+        if (isRecord3(active) && Number(active.count ?? 0) >= maximum) return;
+      }
+      if (options.rateLimit) {
+        const executions = Math.max(1, Math.min(options.rateLimit.executions, 1e5));
+        const windowSeconds = Math.max(1, Math.min(options.rateLimit.windowSeconds, 86400));
+        const windowStart = new Date(Date.parse(now) - windowSeconds * 1e3).toISOString();
+        const recent = this.db.prepare(`
+          SELECT COUNT(*) AS count
+          FROM worker_queue q
+          JOIN proposals p ON p.proposal_id = q.proposal_id
+          WHERE q.status = 'completed'
+            AND q.updated_at >= ?
+            AND (? IS NULL OR q.execution_mode = ?)
+            AND (? IS NULL OR p.action = ?)
+            AND (? IS NULL OR p.tenant_id = ?)
+            AND (? IS NULL OR q.contract_digest = ?)
+        `).get(
+          windowStart,
+          options.executionMode ?? null,
+          options.executionMode ?? null,
+          options.capability ?? null,
+          options.capability ?? null,
+          options.tenant ?? null,
+          options.tenant ?? null,
+          options.contractDigest ?? null,
+          options.contractDigest ?? null
+        );
+        if (isRecord3(recent) && Number(recent.count ?? 0) >= executions) return;
+      }
+      const raw = this.db.prepare(`
+        SELECT q.*
+        FROM worker_queue q
         JOIN proposals p ON p.proposal_id = q.proposal_id
         WHERE (
           (q.status IN ('queued', 'retry_wait') AND q.next_attempt_at <= ?)
           OR (q.status = 'leased' AND q.lease_expires_at <= ?)
         )
           AND p.state IN ('approved', 'pending_worker', 'failed')
+          AND (? IS NULL OR q.execution_mode = ?)
+          AND (? IS NULL OR p.action = ?)
+          AND (? IS NULL OR p.tenant_id = ?)
+          AND (? IS NULL OR q.contract_digest = ?)
         ORDER BY q.next_attempt_at ASC, q.created_at ASC
         LIMIT 1
-      `).get(now, now);
+      `).get(
+        now,
+        now,
+        options.executionMode ?? null,
+        options.executionMode ?? null,
+        options.capability ?? null,
+        options.capability ?? null,
+        options.tenant ?? null,
+        options.tenant ?? null,
+        options.contractDigest ?? null,
+        options.contractDigest ?? null
+      );
       const item = rowToWorkerQueueItem(raw);
       if (!item) return;
+      const proposal = this.requireProposal(item.proposal_id);
+      if (options.proposalTtlSeconds !== void 0) {
+        const ttlSeconds = Math.max(60, Math.min(options.proposalTtlSeconds, 2592e3));
+        const expiresAt = Date.parse(proposal.created_at) + ttlSeconds * 1e3;
+        if (!Number.isFinite(expiresAt) || expiresAt <= Date.parse(now)) {
+          this.blockQueuedWorkerItem(item, options.workerId, "SUPERVISED_WORKER_PROPOSAL_EXPIRED", now);
+          return;
+        }
+      }
+      if (options.policyExecution) {
+        const trips = this.workerPolicyExecutionLimitTrips({
+          proposal,
+          policy: options.policyExecution.policy,
+          limits: options.policyExecution.limits,
+          now
+        });
+        if (trips.length > 0) {
+          this.blockQueuedWorkerItem(
+            item,
+            options.workerId,
+            "SUPERVISED_WORKER_POLICY_LIMIT_EXCEEDED",
+            now,
+            { policy: options.policyExecution.policy, tripped_limits: trips }
+          );
+          return;
+        }
+      }
+      const leaseId = workerLeaseId(item.proposal_id, options.workerId, item.attempts + 1, now);
       this.db.prepare(`
         UPDATE worker_queue
         SET status = 'leased', attempts = attempts + 1, lease_owner = ?,
-            lease_expires_at = ?, updated_at = ?
+            lease_id = ?, lease_expires_at = ?, last_error_code = NULL,
+            terminal_outcome = NULL, updated_at = ?
         WHERE proposal_id = ?
-      `).run(options.workerId, leaseExpiresAt, now, item.proposal_id);
-      const proposal = this.requireProposal(item.proposal_id);
+      `).run(options.workerId, leaseId, leaseExpiresAt, now, item.proposal_id);
       if (proposal.state === "failed") {
         this.db.prepare("UPDATE proposals SET state = 'pending_worker', updated_at = ? WHERE proposal_id = ?").run(now, item.proposal_id);
       }
       this.appendEvent(item.proposal_id, "writeback_worker_claimed", options.workerId, {
         attempt: item.attempts + 1,
         max_attempts: item.max_attempts,
+        execution_mode: item.execution_mode,
+        contract_digest: item.contract_digest ?? null,
+        lease_id: leaseId,
         lease_expires_at: leaseExpiresAt
       });
       claimed = this.workerQueueItem(item.proposal_id);
     });
     return claimed;
   }
-  completeWorkerItem(proposalId, workerId, outcome, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  assertWorkerPolicyExecutionLimits(input) {
+    const proposal = this.requireProposal(input.proposalId);
+    const trips = this.workerPolicyExecutionLimitTrips({
+      proposal,
+      policy: input.policy,
+      limits: input.limits,
+      now: input.now ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (trips.length > 0) {
+      throw new ProposalStoreError(
+        "SUPERVISED_WORKER_POLICY_LIMIT_EXCEEDED",
+        `execution-time policy limit no longer permits proposal ${proposal.proposal_id}`
+      );
+    }
+  }
+  blockQueuedWorkerItem(item, actor, errorCode, now, payload = {}) {
+    this.db.prepare(`
+      UPDATE worker_queue
+      SET status = 'blocked', lease_owner = NULL, lease_id = NULL,
+          lease_expires_at = NULL, last_error_code = ?,
+          terminal_outcome = NULL, updated_at = ?
+      WHERE proposal_id = ?
+    `).run(errorCode, now, item.proposal_id);
+    this.appendEvent(item.proposal_id, "writeback_worker_blocked", actor, {
+      error_code: errorCode,
+      execution_mode: item.execution_mode,
+      contract_digest: item.contract_digest ?? null,
+      ...payload
+    });
+  }
+  workerPolicyExecutionLimitTrips(input) {
+    if (input.limits.length === 0) return [];
+    const actor = `policy:${input.policy}`;
+    const candidateApproval = this.db.prepare(`
+      SELECT approval_id
+      FROM approvals
+      WHERE proposal_id = ?
+        AND approver = ?
+        AND status = 'approved'
+        AND proposal_hash = ?
+        AND proposal_version = ?
+      LIMIT 1
+    `).get(
+      input.proposal.proposal_id,
+      actor,
+      input.proposal.proposal_hash,
+      input.proposal.proposal_version
+    );
+    if (!isRecord3(candidateApproval)) return [];
+    const window2 = utcDayWindow(input.now);
+    const rows = this.db.prepare(`
+      SELECT DISTINCT
+        p.proposal_id,
+        p.business_object,
+        p.object_id,
+        p.change_set_json
+      FROM worker_queue q
+      JOIN proposals p ON p.proposal_id = q.proposal_id
+      JOIN approvals a ON a.proposal_id = p.proposal_id
+      WHERE a.approver = ?
+        AND a.status = 'approved'
+        AND p.tenant_id = ?
+        AND (
+          (q.status = 'leased' AND q.lease_expires_at > ?)
+          OR (
+            q.status = 'completed'
+            AND q.terminal_outcome IN ('applied', 'already_applied')
+            AND q.updated_at >= ?
+            AND q.updated_at < ?
+          )
+          OR (
+            q.status = 'reconciliation_required'
+            AND q.updated_at >= ?
+            AND q.updated_at < ?
+          )
+          OR (
+            p.state = 'applied'
+            AND p.updated_at >= ?
+            AND p.updated_at < ?
+          )
+        )
+    `).all(
+      actor,
+      input.proposal.tenant_id,
+      input.now,
+      window2.start,
+      window2.end,
+      window2.start,
+      window2.end,
+      window2.start,
+      window2.end
+    );
+    const active = /* @__PURE__ */ new Map();
+    let invalidHistory = false;
+    for (const row of rows) {
+      if (!isRecord3(row)) continue;
+      try {
+        const proposalId = String(row.proposal_id);
+        active.set(proposalId, {
+          proposal_id: proposalId,
+          business_object: String(row.business_object),
+          object_id: String(row.object_id),
+          change_set: parseChangeSet(JSON.parse(String(row.change_set_json)))
+        });
+      } catch {
+        invalidHistory = true;
+        active.set(String(row.proposal_id), {
+          proposal_id: String(row.proposal_id),
+          business_object: String(row.business_object),
+          object_id: String(row.object_id),
+          change_set: input.proposal.change_set
+        });
+      }
+    }
+    active.set(input.proposal.proposal_id, {
+      proposal_id: input.proposal.proposal_id,
+      business_object: input.proposal.business_object,
+      object_id: input.proposal.object_id,
+      change_set: input.proposal.change_set
+    });
+    const trips = [];
+    for (const limit of input.limits) {
+      const scope = limit.scope ?? "tenant_policy";
+      const scoped = [...active.values()].filter((proposal) => scope !== "tenant_policy_object" || proposal.business_object === input.proposal.business_object && proposal.object_id === input.proposal.object_id);
+      if (limit.kind === "count") {
+        const projected2 = scoped.length;
+        if (projected2 > limit.max) {
+          trips.push({
+            ...limit,
+            scope,
+            observed: Math.max(0, projected2 - 1),
+            proposed: 1,
+            projected: projected2,
+            window_start: window2.start,
+            window_end: window2.end,
+            reason: `${scope} execution count ${projected2} exceeds ${limit.max}`
+          });
+        }
+        continue;
+      }
+      const field = limit.field;
+      let projected = 0;
+      let proposed = 0;
+      let invalid = !field || invalidHistory;
+      for (const proposal of scoped) {
+        const value = field ? proposal.change_set.patch[field] : void 0;
+        if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+          invalid = true;
+          continue;
+        }
+        projected += value;
+        if (proposal.proposal_id === input.proposal.proposal_id) proposed = value;
+      }
+      if (invalid || projected > limit.max) {
+        trips.push({
+          ...limit,
+          scope,
+          observed: projected - proposed,
+          proposed,
+          projected,
+          window_start: window2.start,
+          window_end: window2.end,
+          reason: invalid ? `${scope} execution total could not be verified safely${field ? ` for ${field}` : ""}` : `${scope} execution total ${projected} for ${field} exceeds ${limit.max}`
+        });
+      }
+    }
+    return trips;
+  }
+  assertActiveWorkerLease(options) {
+    const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const item = this.assertWorkerLease(options.proposalId, options.workerId, options.leaseId);
+    if (!item.lease_expires_at || Date.parse(item.lease_expires_at) <= Date.parse(now)) {
+      throw new ProposalStoreError("WORKER_LEASE_EXPIRED", `worker lease ${options.leaseId} for ${options.proposalId} has expired`);
+    }
+    return item;
+  }
+  renewWorkerLease(options) {
+    const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const leaseSeconds = Math.max(15, Math.min(options.leaseSeconds ?? 60, 3600));
+    const leaseExpiresAt = new Date(Date.parse(now) + leaseSeconds * 1e3).toISOString();
+    this.transaction(() => {
+      this.assertActiveWorkerLease({ ...options, now });
+      this.db.prepare(`
+        UPDATE worker_queue
+        SET lease_expires_at = ?, updated_at = ?
+        WHERE proposal_id = ? AND status = 'leased' AND lease_owner = ? AND lease_id = ?
+      `).run(leaseExpiresAt, now, options.proposalId, options.workerId, options.leaseId);
+    });
+    return this.requireWorkerQueueItem(options.proposalId);
+  }
+  completeWorkerItem(proposalId, workerId, outcome, now = (/* @__PURE__ */ new Date()).toISOString(), leaseId) {
     this.transaction(() => {
-      this.assertWorkerLease(proposalId, workerId);
+      this.assertWorkerLease(proposalId, workerId, leaseId);
       this.db.prepare(`
         UPDATE worker_queue
-        SET status = 'completed', lease_owner = NULL, lease_expires_at = NULL,
-            last_error_code = NULL, updated_at = ?
+        SET status = 'completed', lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, last_error_code = NULL,
+            terminal_outcome = ?, updated_at = ?
         WHERE proposal_id = ?
-      `).run(now, proposalId);
-      this.appendEvent(proposalId, "writeback_worker_completed", workerId, { outcome });
+      `).run(outcome, now, proposalId);
+      this.appendEvent(proposalId, "writeback_worker_completed", workerId, { outcome, lease_id: leaseId ?? null });
     });
     return this.requireWorkerQueueItem(proposalId);
   }
   retryWorkerItem(options) {
     const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
     this.transaction(() => {
-      const item = this.assertWorkerLease(options.proposalId, options.workerId);
+      const item = this.assertWorkerLease(options.proposalId, options.workerId, options.leaseId);
       const deadLetter = item.attempts >= item.max_attempts;
       this.db.prepare(`
         UPDATE worker_queue
-        SET status = ?, next_attempt_at = ?, lease_owner = NULL,
-            lease_expires_at = NULL, last_error_code = ?, updated_at = ?
+        SET status = ?, next_attempt_at = ?, lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, last_error_code = ?, terminal_outcome = NULL,
+            updated_at = ?
         WHERE proposal_id = ?
       `).run(deadLetter ? "dead_letter" : "retry_wait", options.retryAt, options.errorCode, now, options.proposalId);
       this.appendEvent(options.proposalId, deadLetter ? "writeback_dead_lettered" : "writeback_retry_scheduled", options.workerId, {
         attempt: item.attempts,
         max_attempts: item.max_attempts,
         error_code: options.errorCode,
+        lease_id: options.leaseId ?? null,
         ...deadLetter ? {} : { retry_at: options.retryAt }
       });
     });
@@ -7911,17 +9004,95 @@ var ProposalStore = class {
   deadLetterWorkerItem(options) {
     const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
     this.transaction(() => {
-      const item = this.assertWorkerLease(options.proposalId, options.workerId);
+      const item = this.assertWorkerLease(options.proposalId, options.workerId, options.leaseId);
       this.db.prepare(`
         UPDATE worker_queue
-        SET status = 'dead_letter', lease_owner = NULL, lease_expires_at = NULL,
-            last_error_code = ?, updated_at = ?
+        SET status = 'dead_letter', lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, last_error_code = ?,
+            terminal_outcome = 'dead_letter', updated_at = ?
         WHERE proposal_id = ?
       `).run(options.errorCode, now, options.proposalId);
       this.appendEvent(options.proposalId, "writeback_dead_lettered", options.workerId, {
         attempt: item.attempts,
         max_attempts: item.max_attempts,
-        error_code: options.errorCode
+        error_code: options.errorCode,
+        lease_id: options.leaseId ?? null
+      });
+    });
+    return this.requireWorkerQueueItem(options.proposalId);
+  }
+  blockWorkerItem(options) {
+    const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.transaction(() => {
+      this.assertWorkerLease(options.proposalId, options.workerId, options.leaseId);
+      this.db.prepare(`
+        UPDATE worker_queue
+        SET status = 'blocked', lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, last_error_code = ?,
+            terminal_outcome = 'blocked', updated_at = ?
+        WHERE proposal_id = ?
+      `).run(options.errorCode, now, options.proposalId);
+      this.appendEvent(options.proposalId, "writeback_worker_blocked", options.workerId, {
+        error_code: options.errorCode,
+        lease_id: options.leaseId
+      });
+    });
+    return this.requireWorkerQueueItem(options.proposalId);
+  }
+  requireWorkerReconciliation(options) {
+    const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.transaction(() => {
+      this.assertWorkerLease(options.proposalId, options.workerId, options.leaseId);
+      this.db.prepare(`
+        UPDATE worker_queue
+        SET status = 'reconciliation_required', lease_owner = NULL,
+            lease_id = NULL, lease_expires_at = NULL, last_error_code = ?,
+            terminal_outcome = 'reconciliation_required', updated_at = ?
+        WHERE proposal_id = ?
+      `).run(options.errorCode, now, options.proposalId);
+      this.appendEvent(options.proposalId, "writeback_reconciliation_required", options.workerId, {
+        safe_error_code: options.errorCode,
+        lease_id: options.leaseId
+      });
+    });
+    return this.requireWorkerQueueItem(options.proposalId);
+  }
+  cancelWorkerItem(options) {
+    const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const proposal = this.requireProposal(options.proposalId);
+    assertOperatorDecision(
+      proposal,
+      "worker_cancel",
+      options.actor,
+      options.identity,
+      options.require_verified_identity === true
+    );
+    this.transaction(() => {
+      const item = this.requireWorkerQueueItem(options.proposalId);
+      if (item.status !== "queued" && item.status !== "retry_wait") {
+        throw new ProposalStoreError(
+          "WORKER_ITEM_NOT_CANCELLABLE",
+          `worker queue item ${options.proposalId} is ${item.status}, not safely cancellable before lease`
+        );
+      }
+      this.db.prepare(`
+        UPDATE worker_queue
+        SET status = 'cancelled', lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, terminal_outcome = 'cancelled',
+            updated_at = ?
+        WHERE proposal_id = ?
+      `).run(now, options.proposalId);
+      if (proposal.state === "approved" || proposal.state === "pending_worker") {
+        this.db.prepare(`
+          UPDATE proposals
+          SET state = 'canceled', updated_at = ?
+          WHERE proposal_id = ?
+        `).run(now, options.proposalId);
+      }
+      this.appendEvent(options.proposalId, "writeback_canceled", options.actor, {
+        execution_mode: item.execution_mode,
+        contract_digest: item.contract_digest ?? null,
+        identity: options.identity ? publicIdentitySummary(options.identity) : null
       });
     });
     return this.requireWorkerQueueItem(options.proposalId);
@@ -7950,7 +9121,8 @@ var ProposalStore = class {
       this.db.prepare(`
         UPDATE worker_queue
         SET status = 'queued', attempts = 0, max_attempts = ?, next_attempt_at = ?,
-            lease_owner = NULL, lease_expires_at = NULL, last_error_code = NULL, updated_at = ?
+            lease_owner = NULL, lease_id = NULL, lease_expires_at = NULL,
+            last_error_code = NULL, terminal_outcome = NULL, updated_at = ?
         WHERE proposal_id = ?
       `).run(retryBudget, now, now, options.proposalId);
       if (proposal.state === "failed") {
@@ -7975,7 +9147,8 @@ var ProposalStore = class {
       }
       this.db.prepare(`
         UPDATE worker_queue
-        SET status = 'discarded', lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+        SET status = 'discarded', lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, terminal_outcome = 'discarded', updated_at = ?
         WHERE proposal_id = ?
       `).run(now, options.proposalId);
       this.appendEvent(options.proposalId, "writeback_dead_letter_discarded", options.identity.subject, {
@@ -7993,9 +9166,9 @@ var ProposalStore = class {
     if (!item) throw new ProposalStoreError("WORKER_ITEM_NOT_FOUND", `worker queue item not found for ${proposalId}`);
     return item;
   }
-  assertWorkerLease(proposalId, workerId) {
+  assertWorkerLease(proposalId, workerId, leaseId) {
     const item = this.requireWorkerQueueItem(proposalId);
-    if (item.status !== "leased" || item.lease_owner !== workerId) {
+    if (item.status !== "leased" || item.lease_owner !== workerId || leaseId !== void 0 && item.lease_id !== leaseId) {
       throw new ProposalStoreError("WORKER_LEASE_MISMATCH", `worker ${workerId} does not hold the lease for ${proposalId}`);
     }
     return item;
@@ -8258,6 +9431,642 @@ var ProposalStore = class {
     if (!recommendation) throw new ProposalStoreError("POLICY_RECOMMENDATION_NOT_FOUND", `policy recommendation not found: ${recommendationId}`);
     return recommendation;
   }
+  recordAttentionEvent(input) {
+    let event;
+    const record = () => {
+      event = this.recordAttentionEventInternal(input);
+    };
+    if (this.db.isTransaction) record();
+    else this.transaction(record);
+    if (!event) throw new ProposalStoreError("ATTENTION_EVENT_CREATE_FAILED", "attention event was not persisted");
+    return event;
+  }
+  listAttentionEvents(filters = {}) {
+    const clauses = [];
+    const params = [];
+    if (filters.event_type) {
+      clauses.push("event_type = ?");
+      params.push(filters.event_type);
+    }
+    if (filters.severity) {
+      clauses.push("severity = ?");
+      params.push(filters.severity);
+    }
+    if (filters.proposal_id) {
+      clauses.push("proposal_id = ?");
+      params.push(filters.proposal_id);
+    }
+    if (filters.capability) {
+      clauses.push("capability = ?");
+      params.push(filters.capability);
+    }
+    if (filters.tenant) {
+      clauses.push("EXISTS (SELECT 1 FROM proposals p WHERE p.proposal_id = attention_events.proposal_id AND p.tenant_id = ?)");
+      params.push(filters.tenant);
+    }
+    if (filters.principal) {
+      clauses.push("EXISTS (SELECT 1 FROM proposals p WHERE p.proposal_id = attention_events.proposal_id AND p.principal = ?)");
+      params.push(filters.principal);
+    }
+    if (filters.from) {
+      clauses.push("occurred_at >= ?");
+      params.push(filters.from);
+    }
+    const limit = Math.max(1, Math.min(filters.limit ?? 200, 1e3));
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    return this.db.prepare(`
+      SELECT *
+      FROM attention_events
+      ${where}
+      ORDER BY occurred_at DESC, event_id DESC
+      LIMIT ?
+    `).all(...params, limit).map(rowToAttentionEvent).filter((event) => event !== void 0);
+  }
+  getAttentionEvent(eventId) {
+    return rowToAttentionEvent(
+      this.db.prepare("SELECT * FROM attention_events WHERE event_id = ?").get(eventId)
+    );
+  }
+  listAttentionItems(filters = {}) {
+    const clauses = [];
+    const params = [];
+    if (filters.status) {
+      clauses.push("status = ?");
+      params.push(filters.status);
+    }
+    if (filters.severity) {
+      clauses.push("severity = ?");
+      params.push(filters.severity);
+    }
+    if (filters.capability) {
+      clauses.push("capability = ?");
+      params.push(filters.capability);
+    }
+    if (filters.tenant) {
+      clauses.push(`EXISTS (
+        SELECT 1
+        FROM attention_events ae
+        JOIN proposals p ON p.proposal_id = ae.proposal_id
+        WHERE ae.attention_key = attention_items.attention_key
+          AND p.tenant_id = ?
+      )`);
+      params.push(filters.tenant);
+    }
+    if (filters.principal) {
+      clauses.push(`EXISTS (
+        SELECT 1
+        FROM attention_events ae
+        JOIN proposals p ON p.proposal_id = ae.proposal_id
+        WHERE ae.attention_key = attention_items.attention_key
+          AND p.principal = ?
+      )`);
+      params.push(filters.principal);
+    }
+    const limit = Math.max(1, Math.min(filters.limit ?? 200, 1e3));
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    return this.db.prepare(`
+      SELECT *
+      FROM attention_items
+      ${where}
+      ORDER BY
+        CASE severity WHEN 'critical' THEN 0 WHEN 'warning' THEN 1 ELSE 2 END,
+        last_seen_at DESC,
+        attention_id DESC
+      LIMIT ?
+    `).all(...params, limit).map(rowToAttentionItem).filter((item) => item !== void 0);
+  }
+  getAttentionItem(attentionId) {
+    return rowToAttentionItem(this.db.prepare("SELECT * FROM attention_items WHERE attention_id = ?").get(attentionId));
+  }
+  acknowledgeAttention(input) {
+    const actor = boundedSafeLabel(input.actor, "attention acknowledgement actor", 256);
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.transaction(() => {
+      const item = this.requireAttentionItem(input.attention_id);
+      if (item.status !== "open") {
+        throw new ProposalStoreError("ATTENTION_ITEM_NOT_ACKNOWLEDGEABLE", `attention item ${item.attention_id} is ${item.status}`);
+      }
+      assertAttentionOperatorDecision(
+        item,
+        actor,
+        input.identity,
+        input.require_verified_identity === true
+      );
+      this.db.prepare(`
+        UPDATE attention_items
+        SET status = 'acknowledged', acknowledged_by = ?, acknowledged_at = ?,
+            acknowledgement_identity_json = ?,
+            acknowledgement_decision_hash = ?,
+            acknowledgement_signature = ?,
+            acknowledgement_integrity_hash = ?,
+            last_seen_at = MAX(last_seen_at, ?)
+        WHERE attention_id = ?
+      `).run(
+        actor,
+        now,
+        input.identity ? JSON.stringify(input.identity) : null,
+        input.identity?.decision_hash ?? null,
+        input.identity?.signature ?? null,
+        input.identity?.integrity_hash ?? null,
+        now,
+        item.attention_id
+      );
+    });
+    return this.requireAttentionItem(input.attention_id);
+  }
+  resolveAttention(input) {
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.transaction(() => {
+      const item = this.requireAttentionItem(input.attention_id);
+      if (item.status === "expired") {
+        throw new ProposalStoreError("ATTENTION_ITEM_NOT_RESOLVABLE", `attention item ${item.attention_id} is expired`);
+      }
+      this.db.prepare(`
+        UPDATE attention_items
+        SET status = 'resolved', resolved_at = ?, last_seen_at = MAX(last_seen_at, ?)
+        WHERE attention_id = ?
+      `).run(now, now, item.attention_id);
+    });
+    return this.requireAttentionItem(input.attention_id);
+  }
+  enqueueNotificationDelivery(input) {
+    const sinkId = boundedSinkId(input.sink_id);
+    const event = this.requireAttentionEvent(input.event_id);
+    const attention = input.attention_id ? this.requireAttentionItem(input.attention_id) : void 0;
+    if (attention && event.attention_key !== attention.attention_key) {
+      throw new ProposalStoreError(
+        "NOTIFICATION_ATTENTION_MISMATCH",
+        `attention event ${event.event_id} does not belong to attention item ${attention.attention_id}`
+      );
+    }
+    const maxAttempts = Math.max(1, Math.min(input.max_attempts ?? 5, 100));
+    const status = input.status ?? "pending";
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (!Number.isFinite(Date.parse(now))) {
+      throw new ProposalStoreError("NOTIFICATION_TIME_INVALID", "notification delivery time must be an ISO timestamp");
+    }
+    const nextAttemptAt = input.next_attempt_at ?? now;
+    if (!Number.isFinite(Date.parse(nextAttemptAt))) {
+      throw new ProposalStoreError(
+        "NOTIFICATION_TIME_INVALID",
+        "notification delivery next-attempt time must be an ISO timestamp"
+      );
+    }
+    const deliveryId = notificationDeliveryId(sinkId, event.event_id);
+    this.transaction(() => {
+      const existing = this.getNotificationDelivery(deliveryId);
+      if (existing) {
+        if (existing.sink_id !== sinkId || existing.event_id !== event.event_id || existing.attention_id !== attention?.attention_id) {
+          throw new ProposalStoreError(
+            "NOTIFICATION_DELIVERY_IDEMPOTENCY_MISMATCH",
+            `notification delivery ${deliveryId} already exists with different immutable routing`
+          );
+        }
+        return;
+      }
+      this.db.prepare(`
+        INSERT INTO notification_deliveries (
+          delivery_id, sink_id, event_id, attention_id, status, attempts,
+          max_attempts, next_attempt_at, lease_owner, lease_id,
+          lease_expires_at, last_error_code, external_reference, delivered_at,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, 0, ?, ?, NULL, NULL, NULL, NULL, NULL, NULL, ?, ?)
+      `).run(
+        deliveryId,
+        sinkId,
+        event.event_id,
+        attention?.attention_id ?? null,
+        status,
+        maxAttempts,
+        nextAttemptAt,
+        now,
+        now
+      );
+    });
+    return this.requireNotificationDelivery(deliveryId);
+  }
+  includeNotificationDeliveriesInDigest(input) {
+    const sinkId = boundedSinkId(input.sink_id);
+    const deliveryIds = [...new Set(input.delivery_ids)];
+    if (deliveryIds.length === 0 || deliveryIds.length > 1e3) {
+      throw new ProposalStoreError(
+        "NOTIFICATION_DIGEST_MEMBERS_INVALID",
+        "a notification digest must contain from 1 through 1000 delivery ids"
+      );
+    }
+    const digestEvent = this.requireAttentionEvent(input.digest_event_id);
+    if (digestEvent.event_type !== "notification.digest") {
+      throw new ProposalStoreError(
+        "NOTIFICATION_DIGEST_EVENT_INVALID",
+        "notification digest membership requires a notification.digest event"
+      );
+    }
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (!Number.isFinite(Date.parse(now))) {
+      throw new ProposalStoreError("NOTIFICATION_TIME_INVALID", "notification digest time must be an ISO timestamp");
+    }
+    let included = 0;
+    this.transaction(() => {
+      for (const deliveryId of deliveryIds) {
+        const item = this.requireNotificationDelivery(deliveryId);
+        const digestReference = `digest:${digestEvent.event_id}`;
+        if (item.status === "suppressed" && item.sink_id === sinkId && item.external_reference === digestReference) {
+          continue;
+        }
+        if (item.sink_id !== sinkId || item.status !== "batched") {
+          throw new ProposalStoreError(
+            "NOTIFICATION_DIGEST_MEMBER_STATE_INVALID",
+            `notification delivery ${deliveryId} is not a batched member of sink ${sinkId}`
+          );
+        }
+        this.db.prepare(`
+          UPDATE notification_deliveries
+          SET status = 'suppressed', external_reference = ?, updated_at = ?
+          WHERE delivery_id = ?
+        `).run(digestReference, now, deliveryId);
+        included += 1;
+      }
+    });
+    return included;
+  }
+  claimNotificationDeliveries(input) {
+    const owner = boundedSafeLabel(input.owner, "notification dispatcher identity", 128);
+    const sinkId = input.sink_id ? boundedSinkId(input.sink_id) : void 0;
+    const limit = Math.max(1, Math.min(input.limit ?? 20, 100));
+    const leaseSeconds = Math.max(15, Math.min(input.lease_seconds ?? 60, 3600));
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (!Number.isFinite(Date.parse(now))) {
+      throw new ProposalStoreError("NOTIFICATION_TIME_INVALID", "notification claim time must be an ISO timestamp");
+    }
+    const leaseExpiresAt = new Date(Date.parse(now) + leaseSeconds * 1e3).toISOString();
+    const claimed = [];
+    this.transaction(() => {
+      const rows = this.db.prepare(`
+        SELECT *
+        FROM notification_deliveries
+        WHERE (
+          (status IN ('pending', 'retry_wait') AND next_attempt_at <= ?)
+          OR (status = 'leased' AND lease_expires_at <= ?)
+        )
+          AND (? IS NULL OR sink_id = ?)
+        ORDER BY next_attempt_at ASC, created_at ASC, delivery_id ASC
+        LIMIT ?
+      `).all(now, now, sinkId ?? null, sinkId ?? null, limit);
+      for (const row of rows) {
+        const item = rowToNotificationDelivery(row);
+        if (!item) continue;
+        const leaseId = notificationLeaseId(item.delivery_id, owner, item.attempts + 1, now);
+        this.db.prepare(`
+          UPDATE notification_deliveries
+          SET status = 'leased', attempts = attempts + 1, lease_owner = ?,
+              lease_id = ?, lease_expires_at = ?, last_error_code = NULL,
+              updated_at = ?
+          WHERE delivery_id = ?
+        `).run(owner, leaseId, leaseExpiresAt, now, item.delivery_id);
+        claimed.push(this.requireNotificationDelivery(item.delivery_id));
+      }
+    });
+    return claimed;
+  }
+  completeNotificationDelivery(input) {
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const externalReference = input.external_reference ? boundedSafeLabel(input.external_reference, "notification external reference", 256) : void 0;
+    this.transaction(() => {
+      this.assertNotificationLease(input.delivery_id, input.owner, input.lease_id, now);
+      this.db.prepare(`
+        UPDATE notification_deliveries
+        SET status = 'delivered', lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, last_error_code = NULL,
+            external_reference = COALESCE(?, external_reference),
+            delivered_at = ?, updated_at = ?
+        WHERE delivery_id = ?
+      `).run(externalReference ?? null, now, now, input.delivery_id);
+    });
+    return this.requireNotificationDelivery(input.delivery_id);
+  }
+  failNotificationDelivery(input) {
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const errorCode = boundedSafeErrorCode(input.error_code);
+    this.transaction(() => {
+      const item = this.assertNotificationLease(input.delivery_id, input.owner, input.lease_id, now);
+      const retryable = input.retryable && item.attempts < item.max_attempts;
+      const retryAt = retryable ? input.retry_at ?? new Date(Date.parse(now) + 1e3).toISOString() : now;
+      if (!Number.isFinite(Date.parse(retryAt))) {
+        throw new ProposalStoreError("NOTIFICATION_RETRY_TIME_INVALID", "notification retry time must be an ISO timestamp");
+      }
+      this.db.prepare(`
+        UPDATE notification_deliveries
+        SET status = ?, next_attempt_at = ?, lease_owner = NULL, lease_id = NULL,
+            lease_expires_at = NULL, last_error_code = ?, updated_at = ?
+        WHERE delivery_id = ?
+      `).run(retryable ? "retry_wait" : "dead_letter", retryAt, errorCode, now, input.delivery_id);
+    });
+    return this.requireNotificationDelivery(input.delivery_id);
+  }
+  listNotificationDeliveries(filters = {}) {
+    const clauses = [];
+    const params = [];
+    for (const [column, value] of [
+      ["status", filters.status],
+      ["sink_id", filters.sink_id],
+      ["event_id", filters.event_id],
+      ["attention_id", filters.attention_id]
+    ]) {
+      if (!value) continue;
+      clauses.push(`${column} = ?`);
+      params.push(value);
+    }
+    const limit = Math.max(1, Math.min(filters.limit ?? 200, 1e3));
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    return this.db.prepare(`
+      SELECT *
+      FROM notification_deliveries
+      ${where}
+      ORDER BY created_at DESC, delivery_id DESC
+      LIMIT ?
+    `).all(...params, limit).map(rowToNotificationDelivery).filter((delivery) => delivery !== void 0);
+  }
+  getNotificationDelivery(deliveryId) {
+    return rowToNotificationDelivery(
+      this.db.prepare("SELECT * FROM notification_deliveries WHERE delivery_id = ?").get(deliveryId)
+    );
+  }
+  requeueNotificationDelivery(input) {
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const reason = boundedSafeLabel(input.reason, "notification replay reason", 256);
+    this.transaction(() => {
+      const item = this.requireNotificationDelivery(input.delivery_id);
+      if (!["dead_letter", "suppressed", "batched"].includes(item.status)) {
+        throw new ProposalStoreError(
+          "NOTIFICATION_DELIVERY_NOT_REQUEUEABLE",
+          `notification delivery ${item.delivery_id} is ${item.status}`
+        );
+      }
+      assertNotificationReplayOperatorDecision(item, input.identity, reason);
+      const event = this.requireAttentionEvent(item.event_id);
+      this.db.prepare(`
+        UPDATE notification_deliveries
+        SET status = 'pending', attempts = 0, next_attempt_at = ?,
+            lease_owner = NULL, lease_id = NULL, lease_expires_at = NULL,
+            last_error_code = NULL, delivered_at = NULL, updated_at = ?
+        WHERE delivery_id = ?
+      `).run(now, now, item.delivery_id);
+      this.recordAttentionEventInternal({
+        event_type: "notification.replayed",
+        severity: "informational",
+        environment: event.environment,
+        ...event.proposal_id ? { proposal_id: event.proposal_id } : {},
+        ...event.job_id ? { job_id: event.job_id } : {},
+        ...event.operation_id ? { operation_id: event.operation_id } : {},
+        ...event.correlation_id ? { correlation_id: event.correlation_id } : {},
+        ...event.capability ? { capability: event.capability } : {},
+        ...event.contract_digest ? { contract_digest: event.contract_digest } : {},
+        attention_required: false,
+        immediate_default: false,
+        summary: `Notification delivery ${item.delivery_id} requeued by a verified operator`,
+        ...event.workbench_path ? { workbench_path: event.workbench_path } : {},
+        details: {
+          delivery_id: item.delivery_id,
+          sink_id: item.sink_id,
+          replayed_event_id: item.event_id,
+          operator_subject: input.identity.subject,
+          identity_provider: input.identity.provider,
+          operator_decision_hash: input.identity.decision_hash,
+          reason,
+          approval_replayed: false,
+          mutation_replayed: false,
+          source_database_changed: false
+        },
+        source_event_key: `notification-replay:${item.delivery_id}:${input.identity.decision_hash}`,
+        now
+      });
+    });
+    return this.requireNotificationDelivery(input.delivery_id);
+  }
+  recordAttentionEventInternal(input) {
+    assertAttentionEventInput(input);
+    const occurredAt = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const environment = boundedSafeLabel(input.environment, "attention environment", 64);
+    const capability = input.capability ? boundedSafeLabel(input.capability, "attention capability", 256) : void 0;
+    const contractDigest = input.contract_digest;
+    const attentionRequired = input.attention_required ?? defaultAttentionEventTypes.has(input.event_type);
+    const immediateDefault = input.immediate_default ?? defaultImmediateAttentionEventTypes.has(input.event_type);
+    const details = Object.fromEntries(
+      Object.entries(input.details ?? {}).sort(([left], [right]) => left.localeCompare(right))
+    );
+    const sourceEventKey = input.source_event_key ? boundedSafeLabel(input.source_event_key, "attention source event key", 512) : canonicalJsonDigest({
+      event_type: input.event_type,
+      occurred_at: occurredAt,
+      proposal_id: input.proposal_id ?? null,
+      job_id: input.job_id ?? null,
+      operation_id: input.operation_id ?? null,
+      capability: capability ?? null,
+      details
+    });
+    const eventId = attentionEventId(sourceEventKey, input.event_type);
+    const attentionKey = attentionRequired ? boundedSafeLabel(
+      input.attention_key ?? defaultAttentionKey({
+        environment,
+        event_type: input.event_type,
+        capability,
+        contract_digest: contractDigest,
+        details
+      }),
+      "attention coalescing key",
+      512
+    ) : void 0;
+    const unsigned = {
+      schema_version: "synapsor.attention-event.v1",
+      event_id: eventId,
+      event_type: input.event_type,
+      severity: input.severity,
+      occurred_at: occurredAt,
+      environment,
+      ...input.proposal_id ? { proposal_id: boundedSafeLabel(input.proposal_id, "attention proposal id", 256) } : {},
+      ...input.job_id ? { job_id: boundedSafeLabel(input.job_id, "attention job id", 256) } : {},
+      ...input.operation_id ? { operation_id: boundedSafeLabel(input.operation_id, "attention operation id", 256) } : {},
+      ...input.correlation_id ? { correlation_id: boundedSafeLabel(input.correlation_id, "attention correlation id", 256) } : {},
+      ...capability ? { capability } : {},
+      ...contractDigest ? { contract_digest: contractDigest } : {},
+      ...attentionKey ? { attention_key: attentionKey } : {},
+      attention_required: attentionRequired,
+      immediate_default: immediateDefault,
+      summary: boundedSafeLabel(input.summary ?? attentionEventTitle(input.event_type), "attention summary", 512),
+      ...input.approval_source ? { approval_source: input.approval_source } : {},
+      ...input.worker_state ? { worker_state: boundedSafeLabel(input.worker_state, "attention worker state", 128) } : {},
+      ...input.failure_class ? { failure_class: boundedSafeLabel(input.failure_class, "attention failure class", 128) } : {},
+      ...input.expires_at ? { expires_at: input.expires_at } : {},
+      ...input.workbench_path ? { workbench_path: boundedWorkbenchPath(input.workbench_path) } : {},
+      details
+    };
+    assertNoSecretMaterial(unsigned, `attention_event.${eventId}`);
+    const event = {
+      ...unsigned,
+      payload_hash: canonicalJsonDigest(unsigned)
+    };
+    const existing = rowToAttentionEvent(this.db.prepare("SELECT * FROM attention_events WHERE event_id = ?").get(eventId));
+    if (existing) {
+      if (existing.payload_hash !== event.payload_hash) {
+        throw new ProposalStoreError(
+          "ATTENTION_EVENT_IDEMPOTENCY_MISMATCH",
+          `attention event ${eventId} already exists with different immutable content`
+        );
+      }
+      return existing;
+    }
+    this.db.prepare(`
+      INSERT INTO attention_events (
+        event_id, schema_version, event_type, severity, occurred_at, environment,
+        proposal_id, job_id, operation_id, correlation_id, capability,
+        contract_digest, attention_key, attention_required, immediate_default,
+        summary, approval_source, worker_state, failure_class, expires_at,
+        workbench_path, details_json, payload_hash, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      event.event_id,
+      event.schema_version,
+      event.event_type,
+      event.severity,
+      event.occurred_at,
+      event.environment,
+      event.proposal_id ?? null,
+      event.job_id ?? null,
+      event.operation_id ?? null,
+      event.correlation_id ?? null,
+      event.capability ?? null,
+      event.contract_digest ?? null,
+      event.attention_key ?? null,
+      event.attention_required ? 1 : 0,
+      event.immediate_default ? 1 : 0,
+      event.summary,
+      event.approval_source ?? null,
+      event.worker_state ?? null,
+      event.failure_class ?? null,
+      event.expires_at ?? null,
+      event.workbench_path ?? null,
+      JSON.stringify(event.details),
+      event.payload_hash,
+      event.occurred_at
+    );
+    if (event.attention_required && event.attention_key) this.projectAttentionItem(event);
+    if (event.proposal_id && event.event_type === "proposal.expired") {
+      this.closeProposalExpiryAttention(event, "expired");
+    } else if (event.proposal_id && (event.event_type === "proposal.applied" || event.event_type === "proposal.cancelled" || event.event_type === "proposal.refused")) {
+      this.closeProposalExpiryAttention(event, "resolved");
+    }
+    return event;
+  }
+  closeProposalExpiryAttention(event, status) {
+    if (!event.proposal_id) return;
+    this.db.prepare(`
+      UPDATE attention_items
+      SET status = ?,
+          event_type = ?,
+          title = ?,
+          latest_event_id = ?,
+          resolved_at = CASE WHEN ? = 'resolved' THEN ? ELSE NULL END,
+          last_seen_at = MAX(last_seen_at, ?)
+      WHERE status IN ('open', 'acknowledged')
+        AND attention_key IN (
+          SELECT DISTINCT attention_key
+          FROM attention_events
+          WHERE proposal_id = ?
+            AND event_type = 'proposal.expiring'
+            AND attention_key IS NOT NULL
+        )
+    `).run(
+      status,
+      event.event_type,
+      event.summary,
+      event.event_id,
+      status,
+      event.occurred_at,
+      event.occurred_at,
+      event.proposal_id
+    );
+  }
+  projectAttentionItem(event) {
+    const attentionKey = event.attention_key;
+    if (!attentionKey) return;
+    const existing = rowToAttentionItem(this.db.prepare("SELECT * FROM attention_items WHERE attention_key = ?").get(attentionKey));
+    if (!existing) {
+      this.db.prepare(`
+        INSERT INTO attention_items (
+          attention_id, attention_key, status, severity, environment, event_type,
+          capability, contract_digest, title, occurrence_count, first_event_id,
+          latest_event_id, first_seen_at, last_seen_at, acknowledged_by,
+          acknowledged_at, resolved_at, expires_at
+        ) VALUES (?, ?, 'open', ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, NULL, NULL, NULL, ?)
+      `).run(
+        attentionItemId(attentionKey),
+        attentionKey,
+        event.severity,
+        event.environment,
+        event.event_type,
+        event.capability ?? null,
+        event.contract_digest ?? null,
+        event.summary,
+        event.event_id,
+        event.event_id,
+        event.occurred_at,
+        event.occurred_at,
+        event.expires_at ?? null
+      );
+      return;
+    }
+    const severity = attentionSeverityRank(event.severity) > attentionSeverityRank(existing.severity) ? event.severity : existing.severity;
+    this.db.prepare(`
+      UPDATE attention_items
+      SET status = 'open', severity = ?, event_type = ?, title = ?,
+          occurrence_count = occurrence_count + 1, latest_event_id = ?,
+          last_seen_at = ?, acknowledged_by = NULL, acknowledged_at = NULL,
+          acknowledgement_identity_json = NULL,
+          acknowledgement_decision_hash = NULL,
+          acknowledgement_signature = NULL,
+          acknowledgement_integrity_hash = NULL,
+          resolved_at = NULL,
+          expires_at = COALESCE(?, expires_at)
+      WHERE attention_id = ?
+    `).run(
+      severity,
+      event.event_type,
+      event.summary,
+      event.event_id,
+      event.occurred_at,
+      event.expires_at ?? null,
+      existing.attention_id
+    );
+  }
+  requireAttentionItem(attentionId) {
+    const item = this.getAttentionItem(attentionId);
+    if (!item) throw new ProposalStoreError("ATTENTION_ITEM_NOT_FOUND", `attention item not found: ${attentionId}`);
+    return item;
+  }
+  requireAttentionEvent(eventId) {
+    const event = rowToAttentionEvent(this.db.prepare("SELECT * FROM attention_events WHERE event_id = ?").get(eventId));
+    if (!event) throw new ProposalStoreError("ATTENTION_EVENT_NOT_FOUND", `attention event not found: ${eventId}`);
+    return event;
+  }
+  requireNotificationDelivery(deliveryId) {
+    const delivery = this.getNotificationDelivery(deliveryId);
+    if (!delivery) {
+      throw new ProposalStoreError("NOTIFICATION_DELIVERY_NOT_FOUND", `notification delivery not found: ${deliveryId}`);
+    }
+    return delivery;
+  }
+  assertNotificationLease(deliveryId, owner, leaseId, now) {
+    const item = this.requireNotificationDelivery(deliveryId);
+    if (item.status !== "leased" || item.lease_owner !== owner || item.lease_id !== leaseId) {
+      throw new ProposalStoreError(
+        "NOTIFICATION_LEASE_MISMATCH",
+        `dispatcher ${owner} does not hold lease ${leaseId} for ${deliveryId}`
+      );
+    }
+    if (!item.lease_expires_at || Date.parse(item.lease_expires_at) <= Date.parse(now)) {
+      throw new ProposalStoreError("NOTIFICATION_LEASE_EXPIRED", `notification lease ${leaseId} has expired`);
+    }
+    return item;
+  }
   enqueueCloudOutbox(input) {
     const eventId = input.event_id.trim();
     if (!eventId) throw new ProposalStoreError("CLOUD_OUTBOX_EVENT_ID_REQUIRED", "cloud outbox event_id is required");
@@ -8433,6 +10242,92 @@ var ProposalStore = class {
     if (!item) throw new ProposalStoreError("CLOUD_OUTBOX_EVENT_NOT_FOUND", `cloud outbox event not found: ${eventId}`);
     return item;
   }
+  workerControlState() {
+    const raw = this.getRunnerState("supervised_worker_control");
+    if (!raw) return defaultWorkerControlState();
+    return parseWorkerControlState(raw);
+  }
+  updateWorkerControl(input) {
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const current = this.workerControlState();
+    assertWorkerControlTarget(input);
+    assertWorkerControlOperatorDecision(
+      current,
+      input,
+      input.actor,
+      input.identity,
+      input.require_verified_identity === true
+    );
+    let mode = current.mode;
+    let controls = [...current.capability_controls];
+    if (input.action === "pause") mode = "paused";
+    else if (input.action === "resume") mode = "active";
+    else if (input.action === "drain") mode = "draining";
+    else {
+      const capability = input.capability;
+      const contractDigest = input.contract_digest;
+      const keyMatches = (entry) => entry.capability === capability && entry.contract_digest === contractDigest;
+      const existing = controls.find(keyMatches);
+      if (existing?.status === "revoked" && input.action === "capability_enable") {
+        throw new ProposalStoreError(
+          "WORKER_DIGEST_REVOKED",
+          `revoked supervised-worker digest ${contractDigest} cannot be re-enabled`
+        );
+      }
+      const status = input.action === "capability_enable" ? "enabled" : input.action === "capability_disable" ? "disabled" : "revoked";
+      controls = [
+        ...controls.filter((entry) => !keyMatches(entry)),
+        {
+          capability,
+          contract_digest: contractDigest,
+          status,
+          updated_at: now,
+          actor: input.actor
+        }
+      ].sort((left, right) => left.capability.localeCompare(right.capability) || left.contract_digest.localeCompare(right.contract_digest));
+    }
+    const unsigned = {
+      schema_version: "synapsor.worker-control.v1",
+      mode,
+      revision: current.revision + 1,
+      capability_controls: controls,
+      ...input.identity ? { last_decision: input.identity } : {},
+      updated_at: now
+    };
+    const updated = {
+      ...unsigned,
+      integrity_hash: canonicalJsonDigest(unsigned)
+    };
+    assertNoSecretMaterial(updated, "runner_state.supervised_worker_control");
+    this.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO runner_state (key, value_json, updated_at)
+        VALUES ('supervised_worker_control', ?, ?)
+        ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json, updated_at = excluded.updated_at
+      `).run(JSON.stringify(updated), now);
+      const global = input.action === "pause" || input.action === "resume" || input.action === "drain";
+      const eventType = input.action === "resume" || input.action === "capability_enable" ? "capability.activated" : global ? "worker.paused" : "capability.revoked";
+      this.recordAttentionEventInternal({
+        event_type: eventType,
+        severity: "informational",
+        environment: input.environment ? boundedSafeLabel(input.environment, "worker control environment", 64) : "unknown",
+        ...input.capability ? { capability: input.capability } : {},
+        ...input.contract_digest ? { contract_digest: input.contract_digest } : {},
+        attention_required: false,
+        immediate_default: false,
+        summary: workerControlSummary(input),
+        worker_state: mode,
+        details: {
+          control_action: input.action,
+          control_revision: updated.revision,
+          source_database_changed: false
+        },
+        source_event_key: `worker-control:${updated.revision}:${updated.integrity_hash}`,
+        now
+      });
+    });
+    return updated;
+  }
   setRunnerState(key, value) {
     assertNoSecretMaterial(value, `runner_state.${key}`);
     this.db.prepare(`
@@ -8464,6 +10359,9 @@ var ProposalStore = class {
       { table: "shadow_study_cases", kind: "shadow_study_case", key: "case_id", created: "created_at", proposal: "proposal_id", tenant: "tenant_id", capability: "capability" },
       { table: "shadow_outcomes", kind: "shadow_outcome", key: "outcome_id", created: "created_at", proposal: "proposal_id", tenant: "tenant_id" },
       { table: "worker_queue", kind: "worker_queue_item", key: "proposal_id", created: "created_at", proposal: "proposal_id" },
+      { table: "attention_events", kind: "attention_event", key: "event_id", created: "created_at", proposal: "proposal_id", capability: "capability" },
+      { table: "attention_items", kind: "attention_item", key: "attention_id", created: "first_seen_at", capability: "capability" },
+      { table: "notification_deliveries", kind: "notification_delivery", key: "delivery_id", created: "created_at" },
       { table: "runner_state", kind: "runner_state", key: "key", created: "updated_at" },
       { table: "policy_recommendations", kind: "policy_recommendation", key: "recommendation_id", created: "created_at", tenant: "tenant_id", capability: "capability" },
       { table: "cloud_outbox", kind: "cloud_outbox_event", key: "event_id", created: "created_at", proposal: "proposal_id" },
@@ -9036,10 +10934,52 @@ var ProposalStore = class {
     });
   }
   appendEvent(proposalId, kind, actor, payload) {
+    const append = () => {
+      const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      const result = this.db.prepare(`
+        INSERT INTO proposal_events (proposal_id, kind, actor, payload_json, created_at)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(proposalId, kind, actor, JSON.stringify(payload), createdAt);
+      const proposal = this.requireProposal(proposalId);
+      for (const event of attentionEventsForProposalEvent({
+        proposal,
+        proposal_event_id: String(result.lastInsertRowid),
+        kind,
+        actor,
+        payload,
+        environment: this.attentionEnvironment(),
+        occurred_at: createdAt
+      })) {
+        this.recordAttentionEventInternal(event);
+      }
+      if (proposal.state !== "pending_review") {
+        this.resolveSatisfiedProposalReviewAttention(proposal, createdAt);
+      }
+    };
+    if (this.db.isTransaction) append();
+    else this.transaction(append);
+  }
+  attentionEnvironment() {
+    const context = this.getRunnerState("attention_context");
+    const environment = context?.environment;
+    return typeof environment === "string" && /^(development|staging|production|unknown)$/.test(environment) ? environment : "unknown";
+  }
+  resolveSatisfiedProposalReviewAttention(proposal, now) {
+    const attentionKey = proposalReviewAttentionKey(proposal, this.attentionEnvironment());
+    const pending = this.db.prepare(`
+      SELECT COUNT(DISTINCT p.proposal_id) AS count
+      FROM attention_events ae
+      JOIN proposals p ON p.proposal_id = ae.proposal_id
+      WHERE ae.attention_key = ?
+        AND p.state = 'pending_review'
+    `).get(attentionKey);
+    if (isRecord3(pending) && Number(pending.count ?? 0) > 0) return;
     this.db.prepare(`
-      INSERT INTO proposal_events (proposal_id, kind, actor, payload_json, created_at)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(proposalId, kind, actor, JSON.stringify(payload), (/* @__PURE__ */ new Date()).toISOString());
+      UPDATE attention_items
+      SET status = 'resolved', resolved_at = ?, last_seen_at = MAX(last_seen_at, ?)
+      WHERE attention_key = ?
+        AND status IN ('open', 'acknowledged')
+    `).run(now, now, attentionKey);
   }
   queryAudit(proposalId) {
     const rows = this.db.prepare("SELECT * FROM query_audit WHERE proposal_id = ? ORDER BY audit_id ASC").all(proposalId);
@@ -9628,174 +11568,1009 @@ function assertProposalIdentity(proposal, hash, version) {
   if (proposal.proposal_hash !== hash) {
     throw new ProposalStoreError("PROPOSAL_HASH_MISMATCH", `proposal ${proposal.proposal_id} hash mismatch`);
   }
-  if (proposal.proposal_version !== version) {
-    throw new ProposalStoreError("PROPOSAL_VERSION_MISMATCH", `proposal ${proposal.proposal_id} version mismatch`);
+  if (proposal.proposal_version !== version) {
+    throw new ProposalStoreError("PROPOSAL_VERSION_MISMATCH", `proposal ${proposal.proposal_id} version mismatch`);
+  }
+}
+function assertWritebackAllowed(proposal, operation) {
+  if (proposal.change_set.mode === "shadow") {
+    throw new ProposalStoreError(
+      "SHADOW_WRITEBACK_DISABLED",
+      `shadow proposal ${proposal.proposal_id} cannot be ${operation}; shadow mode stores proposals, evidence, query audit, and replay only and never mutates the source database`
+    );
+  }
+  if (proposal.change_set.mode === "read_only") {
+    throw new ProposalStoreError(
+      "READ_ONLY_WRITEBACK_DISABLED",
+      `read-only proposal ${proposal.proposal_id} cannot be ${operation}; read-only mode does not allow proposal writeback`
+    );
+  }
+}
+var secretKeyPattern = /(^|[_-])(password|passwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key|cookie|credential|connection[_-]?string|database[_-]?url|read[_-]?url|write[_-]?url)($|[_-])/i;
+var secretValuePattern = /(postgres(?:ql)?:\/\/|mysql:\/\/|Bearer\s+[A-Za-z0-9._~+/=-]+|syn_wbr_[A-Za-z0-9._~+/=-]+|-----BEGIN [A-Z ]*PRIVATE KEY-----)/i;
+function assertNoSecretMaterial(value, path3) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoSecretMaterial(item, `${path3}[${index}]`));
+    return;
+  }
+  if (isRecord3(value)) {
+    for (const [key, entry] of Object.entries(value)) {
+      const entryPath = `${path3}.${key}`;
+      if (secretKeyPattern.test(key)) {
+        throw new ProposalStoreError(
+          "SECRET_MATERIAL_REJECTED",
+          `refusing to persist secret-like field ${entryPath}; remove it from reviewed visible/evidence/query-audit data`
+        );
+      }
+      assertNoSecretMaterial(entry, entryPath);
+    }
+    return;
+  }
+  if (typeof value === "string" && secretValuePattern.test(value)) {
+    throw new ProposalStoreError(
+      "SECRET_MATERIAL_REJECTED",
+      `refusing to persist secret-like value at ${path3}; remove it from reviewed visible/evidence/query-audit data`
+    );
+  }
+}
+function rowToProposal(row) {
+  if (!isRecord3(row)) return void 0;
+  return {
+    proposal_id: String(row.proposal_id),
+    proposal_version: Number(row.proposal_version),
+    proposal_hash: String(row.proposal_hash),
+    action: String(row.action),
+    state: String(row.state),
+    tenant_id: String(row.tenant_id),
+    principal: row.principal == null ? void 0 : String(row.principal),
+    capability: row.capability == null ? void 0 : String(row.capability),
+    interaction_id: row.interaction_id == null ? void 0 : String(row.interaction_id),
+    tool_call_id: row.tool_call_id == null ? void 0 : String(row.tool_call_id),
+    business_object: String(row.business_object),
+    object_id: String(row.object_id),
+    source_kind: String(row.source_kind),
+    source_id: String(row.source_id),
+    source_schema: String(row.source_schema),
+    source_table: String(row.source_table),
+    source_database_mutated: Number(row.source_database_mutated) === 1,
+    change_set: parseChangeSet(JSON.parse(String(row.change_set_json))),
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
+  };
+}
+function rowToEvent(row) {
+  if (!isRecord3(row)) return void 0;
+  return {
+    event_id: Number(row.event_id),
+    proposal_id: String(row.proposal_id),
+    kind: String(row.kind),
+    actor: String(row.actor),
+    payload: JSON.parse(String(row.payload_json)),
+    created_at: String(row.created_at)
+  };
+}
+function rowToApproval(row) {
+  if (!isRecord3(row)) return void 0;
+  const status = String(row.status);
+  if (status !== "approved" && status !== "rejected") return void 0;
+  return {
+    approval_id: Number(row.approval_id),
+    proposal_id: String(row.proposal_id),
+    proposal_version: Number(row.proposal_version),
+    proposal_hash: String(row.proposal_hash),
+    approver: String(row.approver),
+    status,
+    reason: row.reason == null ? void 0 : String(row.reason),
+    identity: row.identity_json == null ? void 0 : JSON.parse(String(row.identity_json)),
+    decision_hash: row.decision_hash == null ? void 0 : String(row.decision_hash),
+    signature: row.signature == null ? void 0 : String(row.signature),
+    integrity_hash: row.integrity_hash == null ? void 0 : String(row.integrity_hash),
+    freshness_proof_digest: row.freshness_proof_digest == null ? void 0 : String(row.freshness_proof_digest),
+    created_at: String(row.created_at)
+  };
+}
+function rowToPolicyRecommendation(row) {
+  if (!isRecord3(row)) return void 0;
+  let unsigned;
+  try {
+    unsigned = JSON.parse(String(row.payload_json));
+  } catch {
+    throw new ProposalStoreError("POLICY_RECOMMENDATION_TAMPERED", "policy recommendation payload is not valid JSON");
+  }
+  const recommendation = { ...unsigned, integrity_hash: String(row.integrity_hash) };
+  assertPolicyRecommendationShape(recommendation);
+  if (recommendation.recommendation_id !== String(row.recommendation_id) || recommendation.tenant_id !== String(row.tenant_id) || recommendation.capability !== String(row.capability) || recommendation.policy !== String(row.policy) || recommendation.base_contract_digest !== String(row.base_contract_digest) || recommendation.status !== String(row.status)) throw new ProposalStoreError("POLICY_RECOMMENDATION_TAMPERED", `policy recommendation ${String(row.recommendation_id)} index fields do not match its signed payload`);
+  const expected = canonicalJsonDigest(policyRecommendationUnsigned(recommendation));
+  if (recommendation.integrity_hash !== expected) throw new ProposalStoreError("POLICY_RECOMMENDATION_TAMPERED", `policy recommendation ${recommendation.recommendation_id} failed its integrity check`);
+  return recommendation;
+}
+function policyRecommendationUnsigned(recommendation) {
+  const { integrity_hash: _integrityHash, ...unsigned } = recommendation;
+  return unsigned;
+}
+function assertPolicyRecommendationShape(recommendation) {
+  if (recommendation.schema_version !== "synapsor.policy-recommendation.v1") throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "unsupported policy recommendation schema version");
+  if (!/^ptr_[a-f0-9]{20}$/.test(recommendation.recommendation_id)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation id is invalid");
+  for (const [name, value] of [["tenant", recommendation.tenant_id], ["capability", recommendation.capability], ["policy", recommendation.policy], ["field", recommendation.field]]) {
+    if (!value || value.length > 256) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", `policy recommendation ${name} is invalid`);
+  }
+  if (!/^sha256:[a-f0-9]{64}$/.test(recommendation.base_contract_digest)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation base digest is invalid");
+  if (!/^sha256:[a-f0-9]{64}$/.test(recommendation.integrity_hash)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation integrity digest is invalid");
+  if (!Number.isFinite(recommendation.current_threshold) || !Number.isFinite(recommendation.proposed_threshold) || !Number.isFinite(recommendation.maximum_increment) || !Number.isFinite(recommendation.absolute_ceiling)) {
+    throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation thresholds must be finite numbers");
+  }
+  if (recommendation.proposed_threshold <= recommendation.current_threshold || recommendation.proposed_threshold - recommendation.current_threshold > recommendation.maximum_increment || recommendation.proposed_threshold > recommendation.absolute_ceiling) {
+    throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation exceeds its reviewed increment or ceiling");
+  }
+  if (!Array.isArray(recommendation.evidence_proposal_ids) || recommendation.evidence_proposal_ids.length === 0 || recommendation.evidence_proposal_ids.length > 1e4) {
+    throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation requires bounded proposal evidence");
+  }
+  if (!isRecord3(recommendation.metrics) || !isRecord3(recommendation.criteria)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation criteria and metrics are required");
+  if (!["pending_review", "approved", "rejected", "exported"].includes(recommendation.status)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation status is invalid");
+}
+function assertPolicyRecommendationIdentity(recommendation, input) {
+  const proof = input.identity;
+  if (!proof.verified || proof.provider === "dev_env") throw new ProposalStoreError("POLICY_RECOMMENDATION_VERIFIED_IDENTITY_REQUIRED", "policy recommendation decisions require a cryptographically verified operator identity");
+  if (proof.subject !== input.actor || proof.decision.subject !== input.actor) throw new ProposalStoreError("POLICY_RECOMMENDATION_IDENTITY_MISMATCH", "policy recommendation actor does not match the verified identity");
+  if (proof.decision.action !== input.action || proof.decision.proposal_id !== recommendation.recommendation_id || proof.decision.proposal_hash !== recommendation.integrity_hash || proof.decision.proposal_version !== 1) {
+    throw new ProposalStoreError("POLICY_RECOMMENDATION_IDENTITY_MISMATCH", "verified operator decision is not bound to this policy recommendation version");
+  }
+  const { integrity_hash: _integrityHash, ...core } = proof;
+  const canonicalCore = JSON.parse(JSON.stringify(core));
+  if (proof.integrity_hash !== canonicalJsonDigest(canonicalCore)) throw new ProposalStoreError("POLICY_RECOMMENDATION_IDENTITY_TAMPERED", "verified operator identity proof failed its integrity check");
+}
+function attentionEventsForProposalEvent(input) {
+  const proposal = input.proposal;
+  const contractDigest = proposal.change_set.contract?.digest;
+  const scopeDigest = canonicalJsonDigest({
+    tenant_id: proposal.tenant_id,
+    principal: proposal.principal ?? null
+  });
+  const sourceKey = (eventType) => `proposal:${proposal.proposal_id}:event:${input.proposal_event_id}:${eventType}`;
+  const base = (eventType, severity) => ({
+    event_type: eventType,
+    severity,
+    environment: input.environment,
+    proposal_id: proposal.proposal_id,
+    capability: proposal.capability ?? proposal.action,
+    ...contractDigest ? { contract_digest: contractDigest } : {},
+    source_event_key: sourceKey(eventType),
+    now: input.occurred_at
+  });
+  const safeCode = safeAttentionPayloadString(input.payload, "safe_error_code") ?? safeAttentionPayloadString(input.payload, "error_code") ?? safeAttentionPayloadString(input.payload, "reason_code");
+  const workerDetails = safeAttentionDetails(input.payload, [
+    "attempt",
+    "max_attempts",
+    "execution_mode",
+    "outcome"
+  ]);
+  const requiredRole = typeof proposal.change_set.approval.required_role === "string" ? proposal.change_set.approval.required_role : "reviewer";
+  const reviewAttention = (summary) => {
+    const attentionKey = proposalReviewAttentionKey(proposal, input.environment);
+    return {
+      ...base("proposal.review_required", "warning"),
+      attention_required: true,
+      immediate_default: true,
+      attention_key: attentionKey,
+      summary: summary ?? `${proposal.capability ?? proposal.action} proposals need ${requiredRole} review`,
+      workbench_path: `/attention/${attentionItemId(attentionKey)}`,
+      details: {
+        required_role: requiredRole,
+        ...safeCode ? { failure_class: safeCode } : {}
+      },
+      ...safeCode ? { failure_class: safeCode } : {}
+    };
+  };
+  const criticalWorkerAttention = (eventType, summary) => {
+    const failureClass = safeCode ?? (eventType === "worker.dead_lettered" ? "RETRY_BUDGET_EXHAUSTED" : eventType === "worker.unknown_outcome" ? "OUTCOME_UNKNOWN" : "RECONCILIATION_REQUIRED");
+    const attentionKey = [
+      input.environment,
+      eventType,
+      proposal.capability ?? proposal.action,
+      contractDigest ?? "no_digest",
+      failureClass,
+      scopeDigest
+    ].join(":");
+    return {
+      ...base(eventType, "critical"),
+      attention_required: true,
+      immediate_default: true,
+      attention_key: attentionKey,
+      summary,
+      workbench_path: `/attention/${attentionItemId(attentionKey)}`,
+      worker_state: eventType.slice("worker.".length),
+      failure_class: failureClass,
+      details: {
+        ...workerDetails,
+        failure_class: failureClass
+      }
+    };
+  };
+  if (input.kind === "proposal_created") {
+    const events = [{
+      ...base("proposal.created", "informational"),
+      attention_required: false,
+      immediate_default: false,
+      details: { source_database_changed: false }
+    }];
+    const approvalMode = proposal.change_set.approval.mode;
+    if (proposal.state === "pending_review" && approvalMode !== "policy") events.push(reviewAttention());
+    return events;
+  }
+  if (input.kind === "proposal_approved") {
+    const policyApproved = input.actor.startsWith("policy:");
+    return [{
+      ...base(policyApproved ? "proposal.auto_approved" : "proposal.approved", "informational"),
+      attention_required: false,
+      immediate_default: false,
+      approval_source: policyApproved ? "policy_auto" : "human",
+      details: safeAttentionDetails(input.payload, ["approvals", "required_approvals", "remaining_approvals"])
+    }];
+  }
+  if (input.kind === "policy_auto_approval_deferred" || input.kind === "proposal_approval_blocked_freshness") {
+    return [reviewAttention(
+      input.kind === "proposal_approval_blocked_freshness" ? `${proposal.capability ?? proposal.action} needs review because its source freshness check failed` : `${proposal.capability ?? proposal.action} exceeded automatic-approval policy and needs human review`
+    )];
+  }
+  if (input.kind === "proposal_rejected" || input.kind === "proposal_failed") {
+    return [{
+      ...base("proposal.refused", "warning"),
+      attention_required: false,
+      immediate_default: false,
+      ...safeCode ? { failure_class: safeCode, details: { failure_class: safeCode } } : {}
+    }];
+  }
+  if (input.kind === "proposal_canceled" || input.kind === "writeback_canceled") {
+    return [{
+      ...base("proposal.cancelled", "informational"),
+      attention_required: false,
+      immediate_default: false
+    }];
+  }
+  if (input.kind === "proposal_conflict" || input.kind === "writeback_conflict" || input.kind === "writeback_intent_conflict") {
+    return [{
+      ...base("proposal.conflict", "warning"),
+      attention_required: false,
+      immediate_default: false,
+      ...safeCode ? { failure_class: safeCode, details: { failure_class: safeCode } } : {}
+    }];
+  }
+  if (input.kind === "proposal_pending_worker" || input.kind === "writeback_worker_queued") {
+    return [{
+      ...base("proposal.queued", "informational"),
+      attention_required: false,
+      immediate_default: false,
+      worker_state: "queued",
+      details: safeAttentionDetails(input.payload, ["execution_mode", "max_attempts"])
+    }];
+  }
+  if (input.kind === "writeback_retry_scheduled") {
+    return [{
+      ...base("worker.retry_scheduled", "warning"),
+      attention_required: false,
+      immediate_default: false,
+      worker_state: "retry_wait",
+      ...safeCode ? { failure_class: safeCode } : {},
+      details: {
+        ...workerDetails,
+        ...safeCode ? { failure_class: safeCode } : {}
+      }
+    }];
+  }
+  if (input.kind === "writeback_dead_lettered") {
+    return [criticalWorkerAttention("worker.dead_lettered")];
+  }
+  if (input.kind === "writeback_worker_blocked") {
+    const failureClass = safeCode ?? "WORKER_POLICY_BLOCKED";
+    if (/PROPOSAL_.*EXPIRED|PROPOSAL_EXPIRED/i.test(failureClass)) {
+      return [{
+        ...base("proposal.expired", "warning"),
+        attention_required: false,
+        immediate_default: false,
+        worker_state: "blocked",
+        failure_class: failureClass,
+        details: {
+          ...workerDetails,
+          failure_class: failureClass
+        }
+      }];
+    }
+    const digestStale = /(?:CONTRACT|DIGEST|GENERATION_LOCK|SCHEMA|POLICY)_.*(?:STALE|MISMATCH|CHANGED)|ACTIVE_CONTRACT_DIGEST/i.test(failureClass);
+    const limitExceeded = /(?:LIMIT|RATE|QUEUE|BUDGET)_.*(?:EXCEEDED|STALE|MISMATCH)|POLICY_LIMIT/i.test(failureClass);
+    const eventType = digestStale ? "contract.digest_stale" : limitExceeded ? "policy.limit_exceeded" : "proposal.refused";
+    const severity = digestStale || limitExceeded ? "critical" : "warning";
+    const attentionRequired = digestStale || limitExceeded;
+    const attentionKey = [
+      input.environment,
+      eventType,
+      proposal.capability ?? proposal.action,
+      contractDigest ?? "no_digest",
+      failureClass,
+      scopeDigest
+    ].join(":");
+    return [{
+      ...base(eventType, severity),
+      attention_required: attentionRequired,
+      immediate_default: attentionRequired,
+      ...attentionRequired ? {
+        attention_key: attentionKey,
+        workbench_path: `/attention/${attentionItemId(attentionKey)}`
+      } : {},
+      worker_state: "blocked",
+      failure_class: failureClass,
+      details: {
+        ...workerDetails,
+        failure_class: failureClass
+      }
+    }];
+  }
+  if (input.kind === "policy_limit_near") {
+    return [{
+      ...base("policy.limit_near", "warning"),
+      attention_required: false,
+      immediate_default: false,
+      summary: `${proposal.capability ?? proposal.action} is approaching a reviewed policy limit`,
+      details: safeAttentionDetails(input.payload, [
+        "kind",
+        "scope",
+        "observed",
+        "proposed",
+        "projected",
+        "max",
+        "window_start",
+        "window_end"
+      ])
+    }];
+  }
+  if (input.kind === "writeback_reconciliation_required" || input.kind === "writeback_intent_reconciliation_required") {
+    return [criticalWorkerAttention("worker.reconciliation_required")];
+  }
+  if ((input.kind === "writeback_failed" || input.kind === "writeback_intent_failed") && (safeCode === "OUTCOME_UNKNOWN" || safeCode === "RECONCILIATION_REQUIRED")) {
+    return [criticalWorkerAttention("worker.unknown_outcome")];
+  }
+  if (input.kind === "writeback_applied" || input.kind === "writeback_already_applied" || input.kind === "writeback_intent_applied" || input.kind === "writeback_intent_already_applied") {
+    return [{
+      ...base("proposal.applied", "informational"),
+      attention_required: false,
+      immediate_default: false,
+      worker_state: "completed",
+      details: safeAttentionDetails(input.payload, ["rows_affected", "source_database_mutated"])
+    }];
+  }
+  if (input.kind === "writeback_worker_completed") {
+    const outcome = safeAttentionPayloadString(input.payload, "outcome");
+    if (outcome === "conflict") {
+      return [{
+        ...base("proposal.conflict", "warning"),
+        attention_required: false,
+        immediate_default: false,
+        worker_state: "completed",
+        details: { outcome }
+      }];
+    }
+    if (outcome === "applied" || outcome === "already_applied") {
+      return [{
+        ...base("proposal.applied", "informational"),
+        attention_required: false,
+        immediate_default: false,
+        worker_state: "completed",
+        details: { outcome }
+      }];
+    }
+  }
+  if (input.kind === "proposal_reconciliation_required") {
+    return [criticalWorkerAttention("worker.reconciliation_required")];
+  }
+  return [];
+}
+function proposalReviewAttentionKey(proposal, environment) {
+  const contractDigest = proposal.change_set.contract?.digest;
+  const requiredRole = typeof proposal.change_set.approval.required_role === "string" ? proposal.change_set.approval.required_role : "reviewer";
+  const scopeDigest = canonicalJsonDigest({
+    tenant_id: proposal.tenant_id,
+    principal: proposal.principal ?? null
+  });
+  return [
+    environment,
+    "proposal.review_required",
+    proposal.capability ?? proposal.action,
+    contractDigest ?? "no_digest",
+    requiredRole,
+    scopeDigest
+  ].join(":");
+}
+function safeAttentionPayloadString(payload, key) {
+  const value = payload[key];
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  return value.trim().slice(0, 128);
+}
+function safeAttentionDetails(payload, keys) {
+  const details = {};
+  for (const key of keys) {
+    const value = payload[key];
+    if (value === null || typeof value === "boolean") details[key] = value;
+    else if (typeof value === "number" && Number.isFinite(value)) details[key] = value;
+    else if (typeof value === "string" && value.trim()) details[key] = value.trim().slice(0, 128);
+  }
+  return details;
+}
+var attentionEventTypes = /* @__PURE__ */ new Set([
+  "proposal.created",
+  "proposal.review_required",
+  "proposal.auto_approved",
+  "proposal.approved",
+  "proposal.queued",
+  "proposal.expiring",
+  "proposal.expired",
+  "proposal.cancelled",
+  "proposal.applied",
+  "proposal.conflict",
+  "proposal.refused",
+  "worker.started",
+  "worker.paused",
+  "worker.unhealthy",
+  "worker.recovered",
+  "worker.queue_backlog",
+  "worker.retry_scheduled",
+  "worker.dead_lettered",
+  "worker.unknown_outcome",
+  "worker.reconciliation_required",
+  "capability.review_required",
+  "capability.activated",
+  "capability.revoked",
+  "contract.digest_stale",
+  "schema.drift_detected",
+  "credential.posture_changed",
+  "policy.limit_near",
+  "policy.limit_exceeded",
+  "sensitive_override_activated",
+  "notification.replayed",
+  "notification.digest"
+]);
+var defaultAttentionEventTypes = /* @__PURE__ */ new Set([
+  "proposal.review_required",
+  "proposal.expiring",
+  "proposal.expired",
+  "worker.unhealthy",
+  "worker.queue_backlog",
+  "worker.dead_lettered",
+  "worker.unknown_outcome",
+  "worker.reconciliation_required",
+  "capability.review_required",
+  "contract.digest_stale",
+  "schema.drift_detected",
+  "credential.posture_changed",
+  "policy.limit_exceeded",
+  "sensitive_override_activated"
+]);
+var defaultImmediateAttentionEventTypes = /* @__PURE__ */ new Set([
+  "proposal.review_required",
+  "proposal.expiring",
+  "worker.unhealthy",
+  "worker.queue_backlog",
+  "worker.dead_lettered",
+  "worker.unknown_outcome",
+  "worker.reconciliation_required",
+  "contract.digest_stale",
+  "schema.drift_detected",
+  "credential.posture_changed",
+  "policy.limit_exceeded"
+]);
+function attentionEventTitle(eventType) {
+  const titles = {
+    "proposal.created": "Proposal created",
+    "proposal.review_required": "Proposal needs human review",
+    "proposal.auto_approved": "Proposal approved by reviewed policy",
+    "proposal.approved": "Proposal approved",
+    "proposal.queued": "Proposal queued for trusted execution",
+    "proposal.expiring": "Approved proposal is approaching expiry",
+    "proposal.expired": "Approved proposal expired without execution",
+    "proposal.cancelled": "Proposal cancelled",
+    "proposal.applied": "Proposal applied",
+    "proposal.conflict": "Guarded writeback conflict",
+    "proposal.refused": "Proposal refused",
+    "worker.started": "Trusted worker started",
+    "worker.paused": "Trusted worker paused",
+    "worker.unhealthy": "Trusted worker needs attention",
+    "worker.recovered": "Trusted worker supervision recovered",
+    "worker.queue_backlog": "Trusted worker queue backlog",
+    "worker.retry_scheduled": "Trusted worker retry scheduled",
+    "worker.dead_lettered": "Trusted worker job dead-lettered",
+    "worker.unknown_outcome": "Database transaction outcome is unknown",
+    "worker.reconciliation_required": "Operator reconciliation is required",
+    "capability.review_required": "Capability needs human review",
+    "capability.activated": "Capability activated",
+    "capability.revoked": "Capability revoked",
+    "contract.digest_stale": "Active contract or policy authority is stale",
+    "schema.drift_detected": "Schema drift blocks active authority",
+    "credential.posture_changed": "Credential posture changed",
+    "policy.limit_near": "Policy limit is approaching",
+    "policy.limit_exceeded": "Policy limit exceeded",
+    "sensitive_override_activated": "Sensitive-field override activated",
+    "notification.replayed": "Notification delivery requeued by a verified operator",
+    "notification.digest": "Runner activity digest"
+  };
+  return titles[eventType];
+}
+function assertAttentionEventInput(input) {
+  if (!attentionEventTypes.has(input.event_type)) {
+    throw new ProposalStoreError("ATTENTION_EVENT_TYPE_INVALID", `unsupported attention event type: ${String(input.event_type)}`);
+  }
+  if (!["informational", "warning", "critical"].includes(input.severity)) {
+    throw new ProposalStoreError("ATTENTION_EVENT_SEVERITY_INVALID", `unsupported attention severity: ${String(input.severity)}`);
+  }
+  if (input.contract_digest && !/^sha256:[a-f0-9]{64}$/.test(input.contract_digest)) {
+    throw new ProposalStoreError("ATTENTION_EVENT_DIGEST_INVALID", "attention event contract digest must be a lowercase sha256 digest");
+  }
+  for (const [label, value] of [["now", input.now], ["expires_at", input.expires_at]]) {
+    if (value !== void 0 && !Number.isFinite(Date.parse(value))) {
+      throw new ProposalStoreError("ATTENTION_EVENT_TIME_INVALID", `attention event ${label} must be an ISO timestamp`);
+    }
+  }
+  const entries = Object.entries(input.details ?? {});
+  if (entries.length > 32) {
+    throw new ProposalStoreError("ATTENTION_EVENT_DETAILS_TOO_LARGE", "attention event details may contain at most 32 safe fields");
+  }
+  for (const [key, value] of entries) {
+    if (!/^[a-z][a-z0-9_]{0,63}$/.test(key)) {
+      throw new ProposalStoreError("ATTENTION_EVENT_DETAIL_KEY_INVALID", `attention event detail key is invalid: ${key}`);
+    }
+    if (typeof value === "string") boundedSafeLabel(value, `attention detail ${key}`, 256);
+    else if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new ProposalStoreError("ATTENTION_EVENT_DETAIL_VALUE_INVALID", `attention event detail ${key} must be finite`);
+    } else if (value !== null && typeof value !== "number" && typeof value !== "boolean") {
+      throw new ProposalStoreError("ATTENTION_EVENT_DETAIL_VALUE_INVALID", `attention event detail ${key} must be scalar`);
+    }
+  }
+  assertNoSecretMaterial(input.details ?? {}, "attention_event.details");
+}
+function boundedSafeLabel(value, label, maximum) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > maximum || /[\u0000-\u001f\u007f]/.test(trimmed)) {
+    throw new ProposalStoreError("ATTENTION_EVENT_FIELD_INVALID", `${label} must be a non-empty bounded single-line value`);
+  }
+  assertNoSecretMaterial({ value: trimmed }, label);
+  return trimmed;
+}
+function boundedWorkbenchPath(value) {
+  const path3 = boundedSafeLabel(value, "attention Workbench path", 512);
+  if (!path3.startsWith("/") || path3.includes("?") || path3.includes("#") || path3.includes("://") || path3.includes("..")) {
+    throw new ProposalStoreError(
+      "ATTENTION_WORKBENCH_PATH_INVALID",
+      "attention Workbench path must be a local absolute path without query, fragment, traversal, or authority"
+    );
+  }
+  return path3;
+}
+function defaultAttentionKey(input) {
+  const failureClass = typeof input.details.failure_class === "string" ? input.details.failure_class : typeof input.details.reason_code === "string" ? input.details.reason_code : "none";
+  return [
+    input.environment,
+    input.event_type,
+    input.capability ?? "global",
+    input.contract_digest ?? "no_digest",
+    failureClass
+  ].join(":");
+}
+function attentionEventId(sourceEventKey, eventType) {
+  const digest = canonicalJsonDigest({ source_event_key: sourceEventKey, event_type: eventType });
+  return `aev_${digest.slice("sha256:".length)}`;
+}
+function attentionItemId(attentionKey) {
+  const digest = canonicalJsonDigest({ attention_key: attentionKey });
+  return `attn_${digest.slice("sha256:".length, "sha256:".length + 32)}`;
+}
+function boundedSinkId(value) {
+  const sinkId = boundedSafeLabel(value, "notification sink id", 128);
+  if (!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(sinkId)) {
+    throw new ProposalStoreError(
+      "NOTIFICATION_SINK_ID_INVALID",
+      "notification sink id must use letters, numbers, underscore, period, or hyphen"
+    );
+  }
+  return sinkId;
+}
+function boundedSafeErrorCode(value) {
+  const errorCode = boundedSafeLabel(value, "notification error code", 128);
+  if (!/^[A-Z][A-Z0-9_]*$/.test(errorCode)) {
+    throw new ProposalStoreError(
+      "NOTIFICATION_ERROR_CODE_INVALID",
+      "notification error code must be an uppercase safe code"
+    );
+  }
+  return errorCode;
+}
+function notificationDeliveryId(sinkId, eventId) {
+  const digest = canonicalJsonDigest({ sink_id: sinkId, event_id: eventId });
+  return `ndl_${digest.slice("sha256:".length, "sha256:".length + 32)}`;
+}
+function notificationLeaseId(deliveryId, owner, attempt, now) {
+  const digest = canonicalJsonDigest({
+    delivery_id: deliveryId,
+    owner,
+    attempt,
+    now
+  });
+  return `nlease_${digest.slice("sha256:".length, "sha256:".length + 32)}`;
+}
+function attentionSeverityRank(severity) {
+  if (severity === "critical") return 3;
+  if (severity === "warning") return 2;
+  return 1;
+}
+function workerControlDecisionSubject(state, target) {
+  assertWorkerControlTarget(target);
+  const targetDigest = canonicalJsonDigest({
+    schema_version: "synapsor.worker-control-decision-subject.v1",
+    current_revision: state.revision,
+    current_integrity_hash: state.integrity_hash,
+    action: target.action,
+    capability: target.capability ?? null,
+    contract_digest: target.contract_digest ?? null
+  });
+  return {
+    proposal_id: `worker_control_${targetDigest.slice("sha256:".length, "sha256:".length + 32)}`,
+    proposal_version: state.revision + 1,
+    proposal_hash: targetDigest
+  };
+}
+function defaultWorkerControlState() {
+  const unsigned = {
+    schema_version: "synapsor.worker-control.v1",
+    mode: "active",
+    revision: 0,
+    capability_controls: [],
+    updated_at: "1970-01-01T00:00:00.000Z"
+  };
+  return { ...unsigned, integrity_hash: canonicalJsonDigest(unsigned) };
+}
+function parseWorkerControlState(value) {
+  if (!isRecord3(value) || value.schema_version !== "synapsor.worker-control.v1" || !["active", "paused", "draining"].includes(String(value.mode)) || !Number.isSafeInteger(value.revision) || Number(value.revision) < 0 || !Array.isArray(value.capability_controls) || typeof value.updated_at !== "string" || typeof value.integrity_hash !== "string") {
+    throw new ProposalStoreError("WORKER_CONTROL_STATE_INVALID", "stored supervised-worker control state is invalid");
+  }
+  const controls = value.capability_controls.map((entry) => {
+    if (!isRecord3(entry) || typeof entry.capability !== "string" || !/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(entry.capability) || typeof entry.contract_digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(entry.contract_digest) || !["enabled", "disabled", "revoked"].includes(String(entry.status)) || typeof entry.updated_at !== "string" || typeof entry.actor !== "string") {
+      throw new ProposalStoreError("WORKER_CONTROL_STATE_INVALID", "stored supervised-worker capability control is invalid");
+    }
+    return {
+      capability: entry.capability,
+      contract_digest: entry.contract_digest,
+      status: entry.status,
+      updated_at: entry.updated_at,
+      actor: entry.actor
+    };
+  });
+  const lastDecision = isRecord3(value.last_decision) ? value.last_decision : void 0;
+  const unsigned = {
+    schema_version: "synapsor.worker-control.v1",
+    mode: value.mode,
+    revision: Number(value.revision),
+    capability_controls: controls,
+    ...lastDecision ? { last_decision: lastDecision } : {},
+    updated_at: value.updated_at
+  };
+  const integrityHash = value.integrity_hash;
+  if (integrityHash !== canonicalJsonDigest(unsigned)) {
+    throw new ProposalStoreError("WORKER_CONTROL_STATE_TAMPERED", "stored supervised-worker control state failed integrity validation");
+  }
+  return { ...unsigned, integrity_hash: integrityHash };
+}
+function assertWorkerControlTarget(target) {
+  const capabilityAction = target.action === "capability_enable" || target.action === "capability_disable" || target.action === "digest_revoke";
+  if (capabilityAction) {
+    if (!target.capability || !/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(target.capability)) {
+      throw new ProposalStoreError("WORKER_CONTROL_CAPABILITY_REQUIRED", `${target.action} requires a fixed capability name`);
+    }
+    if (!target.contract_digest || !/^sha256:[a-f0-9]{64}$/.test(target.contract_digest)) {
+      throw new ProposalStoreError("WORKER_CONTROL_DIGEST_REQUIRED", `${target.action} requires an exact sha256 contract digest`);
+    }
+  } else if (target.capability || target.contract_digest) {
+    throw new ProposalStoreError("WORKER_CONTROL_TARGET_INVALID", `${target.action} is a global control and cannot carry capability authority`);
+  }
+}
+function workerControlOperatorAction(action) {
+  if (action === "pause") return "worker_pause";
+  if (action === "resume") return "worker_resume";
+  if (action === "drain") return "worker_drain";
+  if (action === "capability_enable") return "worker_capability_enable";
+  if (action === "capability_disable") return "worker_capability_disable";
+  return "worker_digest_revoke";
+}
+function assertWorkerControlOperatorDecision(state, target, actor, identity, requireVerified) {
+  if (requireVerified && (!identity || !identity.verified || identity.provider === "dev_env")) {
+    throw new ProposalStoreError(
+      "VERIFIED_OPERATOR_IDENTITY_REQUIRED",
+      `verified operator identity is required to ${target.action} supervised execution`
+    );
+  }
+  if (!identity) return;
+  if (identity.subject !== actor || identity.decision.subject !== actor) {
+    throw new ProposalStoreError("OPERATOR_IDENTITY_MISMATCH", "worker-control identity does not match its actor");
+  }
+  const subject = workerControlDecisionSubject(state, target);
+  if (identity.decision.action !== workerControlOperatorAction(target.action) || identity.decision.proposal_id !== subject.proposal_id || identity.decision.proposal_version !== subject.proposal_version || identity.decision.proposal_hash !== subject.proposal_hash) {
+    throw new ProposalStoreError("OPERATOR_DECISION_MISMATCH", "operator proof is not bound to this exact worker-control revision");
+  }
+  if (identity.decision_hash !== canonicalJsonDigest(identity.decision)) {
+    throw new ProposalStoreError("OPERATOR_IDENTITY_TAMPERED", "worker-control decision hash failed integrity validation");
+  }
+  const { integrity_hash: _integrityHash, ...identityCore } = identity;
+  if (identity.integrity_hash !== canonicalJsonDigest(identityCore)) {
+    throw new ProposalStoreError("OPERATOR_IDENTITY_TAMPERED", "worker-control identity proof failed integrity validation");
+  }
+}
+function workerControlSummary(target) {
+  if (target.action === "pause") return "Supervised execution paused by an operator";
+  if (target.action === "resume") return "Supervised execution resumed by an operator";
+  if (target.action === "drain") return "Supervised execution is draining without new leases";
+  if (target.action === "capability_enable") return `${target.capability} supervised execution enabled for the exact reviewed digest`;
+  if (target.action === "capability_disable") return `${target.capability} supervised execution disabled for the exact reviewed digest`;
+  return `${target.capability} supervised execution digest revoked`;
+}
+function attentionDecisionSubject(item) {
+  return {
+    proposal_id: item.attention_id,
+    proposal_version: item.occurrence_count,
+    proposal_hash: canonicalJsonDigest({
+      schema_version: "synapsor.attention-decision-subject.v1",
+      attention_id: item.attention_id,
+      attention_key: item.attention_key,
+      status: item.status,
+      severity: item.severity,
+      environment: item.environment,
+      event_type: item.event_type,
+      capability: item.capability ?? null,
+      contract_digest: item.contract_digest ?? null,
+      occurrence_count: item.occurrence_count,
+      latest_event_id: item.latest_event_id,
+      last_seen_at: item.last_seen_at
+    })
+  };
+}
+function notificationReplayDecisionSubject(delivery) {
+  return {
+    proposal_id: delivery.delivery_id,
+    proposal_version: Math.max(1, delivery.attempts),
+    proposal_hash: canonicalJsonDigest({
+      schema_version: "synapsor.notification-replay-decision-subject.v1",
+      delivery_id: delivery.delivery_id,
+      sink_id: delivery.sink_id,
+      event_id: delivery.event_id,
+      attention_id: delivery.attention_id ?? null,
+      status: delivery.status,
+      attempts: delivery.attempts,
+      max_attempts: delivery.max_attempts,
+      last_error_code: delivery.last_error_code ?? null,
+      updated_at: delivery.updated_at
+    })
+  };
+}
+function assertNotificationReplayOperatorDecision(delivery, identity, reason) {
+  if (!identity.verified || identity.provider === "dev_env") {
+    throw new ProposalStoreError(
+      "VERIFIED_OPERATOR_IDENTITY_REQUIRED",
+      `verified operator identity is required to replay notification delivery ${delivery.delivery_id}`
+    );
+  }
+  if (identity.subject !== identity.decision.subject) {
+    throw new ProposalStoreError(
+      "OPERATOR_IDENTITY_MISMATCH",
+      "notification replay identity does not match its signed decision subject"
+    );
+  }
+  const subject = notificationReplayDecisionSubject(delivery);
+  if (identity.decision.action !== "notification_replay" || identity.decision.proposal_id !== subject.proposal_id || identity.decision.proposal_version !== subject.proposal_version || identity.decision.proposal_hash !== subject.proposal_hash || identity.decision.reason !== reason) {
+    throw new ProposalStoreError(
+      "OPERATOR_DECISION_MISMATCH",
+      "operator proof is not bound to this exact notification delivery revision and replay reason"
+    );
   }
-}
-function assertWritebackAllowed(proposal, operation) {
-  if (proposal.change_set.mode === "shadow") {
+  if (identity.decision_hash !== canonicalJsonDigest(identity.decision)) {
     throw new ProposalStoreError(
-      "SHADOW_WRITEBACK_DISABLED",
-      `shadow proposal ${proposal.proposal_id} cannot be ${operation}; shadow mode stores proposals, evidence, query audit, and replay only and never mutates the source database`
+      "OPERATOR_IDENTITY_TAMPERED",
+      "notification replay decision hash failed its integrity check"
     );
   }
-  if (proposal.change_set.mode === "read_only") {
+  const { integrity_hash: _integrityHash, ...core } = identity;
+  const canonicalCore = JSON.parse(JSON.stringify(core));
+  if (identity.integrity_hash !== canonicalJsonDigest(canonicalCore)) {
     throw new ProposalStoreError(
-      "READ_ONLY_WRITEBACK_DISABLED",
-      `read-only proposal ${proposal.proposal_id} cannot be ${operation}; read-only mode does not allow proposal writeback`
+      "OPERATOR_IDENTITY_TAMPERED",
+      "notification replay identity proof failed its integrity check"
     );
   }
 }
-var secretKeyPattern = /(^|[_-])(password|passwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key|cookie|credential|connection[_-]?string|database[_-]?url|read[_-]?url|write[_-]?url)($|[_-])/i;
-var secretValuePattern = /(postgres(?:ql)?:\/\/|mysql:\/\/|Bearer\s+[A-Za-z0-9._~+/=-]+|syn_wbr_[A-Za-z0-9._~+/=-]+|-----BEGIN [A-Z ]*PRIVATE KEY-----)/i;
-function assertNoSecretMaterial(value, path3) {
-  if (Array.isArray(value)) {
-    value.forEach((item, index) => assertNoSecretMaterial(item, `${path3}[${index}]`));
-    return;
+function assertAttentionOperatorDecision(item, actor, identity, requireVerified) {
+  if (requireVerified && (!identity || !identity.verified || identity.provider === "dev_env")) {
+    throw new ProposalStoreError(
+      "VERIFIED_OPERATOR_IDENTITY_REQUIRED",
+      `verified operator identity is required to acknowledge attention item ${item.attention_id}`
+    );
   }
-  if (isRecord3(value)) {
-    for (const [key, entry] of Object.entries(value)) {
-      const entryPath = `${path3}.${key}`;
-      if (secretKeyPattern.test(key)) {
-        throw new ProposalStoreError(
-          "SECRET_MATERIAL_REJECTED",
-          `refusing to persist secret-like field ${entryPath}; remove it from reviewed visible/evidence/query-audit data`
-        );
-      }
-      assertNoSecretMaterial(entry, entryPath);
-    }
-    return;
+  if (!identity) return;
+  if (identity.subject !== actor || identity.decision.subject !== actor) {
+    throw new ProposalStoreError(
+      "OPERATOR_IDENTITY_MISMATCH",
+      `operator identity ${identity.subject} does not match attention acknowledgement actor ${actor}`
+    );
   }
-  if (typeof value === "string" && secretValuePattern.test(value)) {
+  const subject = attentionDecisionSubject(item);
+  if (identity.decision.action !== "attention_acknowledge" || identity.decision.proposal_id !== subject.proposal_id || identity.decision.proposal_version !== subject.proposal_version || identity.decision.proposal_hash !== subject.proposal_hash) {
     throw new ProposalStoreError(
-      "SECRET_MATERIAL_REJECTED",
-      `refusing to persist secret-like value at ${path3}; remove it from reviewed visible/evidence/query-audit data`
+      "OPERATOR_DECISION_MISMATCH",
+      "operator proof is not bound to this exact attention item version"
+    );
+  }
+  if (identity.decision_hash !== canonicalJsonDigest(identity.decision)) {
+    throw new ProposalStoreError(
+      "OPERATOR_IDENTITY_TAMPERED",
+      "attention acknowledgement decision hash failed its integrity check"
+    );
+  }
+  const { integrity_hash: _integrityHash, ...core } = identity;
+  const canonicalCore = JSON.parse(JSON.stringify(core));
+  if (identity.integrity_hash !== canonicalJsonDigest(canonicalCore)) {
+    throw new ProposalStoreError(
+      "OPERATOR_IDENTITY_TAMPERED",
+      "attention acknowledgement identity proof failed its integrity check"
     );
   }
 }
-function rowToProposal(row) {
+function rowToAttentionEvent(row) {
   if (!isRecord3(row)) return void 0;
-  return {
-    proposal_id: String(row.proposal_id),
-    proposal_version: Number(row.proposal_version),
-    proposal_hash: String(row.proposal_hash),
-    action: String(row.action),
-    state: String(row.state),
-    tenant_id: String(row.tenant_id),
-    principal: row.principal == null ? void 0 : String(row.principal),
-    capability: row.capability == null ? void 0 : String(row.capability),
-    interaction_id: row.interaction_id == null ? void 0 : String(row.interaction_id),
-    tool_call_id: row.tool_call_id == null ? void 0 : String(row.tool_call_id),
-    business_object: String(row.business_object),
-    object_id: String(row.object_id),
-    source_kind: String(row.source_kind),
-    source_id: String(row.source_id),
-    source_schema: String(row.source_schema),
-    source_table: String(row.source_table),
-    source_database_mutated: Number(row.source_database_mutated) === 1,
-    change_set: parseChangeSet(JSON.parse(String(row.change_set_json))),
-    created_at: String(row.created_at),
-    updated_at: String(row.updated_at)
+  const eventType = String(row.event_type);
+  const severity = String(row.severity);
+  if (!attentionEventTypes.has(eventType) || !["informational", "warning", "critical"].includes(severity)) return void 0;
+  let details;
+  try {
+    const parsed = JSON.parse(String(row.details_json));
+    if (!isRecord3(parsed)) return void 0;
+    details = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return void 0;
+      details[key] = value;
+    }
+  } catch {
+    return void 0;
+  }
+  const event = {
+    schema_version: "synapsor.attention-event.v1",
+    event_id: String(row.event_id),
+    event_type: eventType,
+    severity,
+    occurred_at: String(row.occurred_at),
+    environment: String(row.environment),
+    ...row.proposal_id == null ? {} : { proposal_id: String(row.proposal_id) },
+    ...row.job_id == null ? {} : { job_id: String(row.job_id) },
+    ...row.operation_id == null ? {} : { operation_id: String(row.operation_id) },
+    ...row.correlation_id == null ? {} : { correlation_id: String(row.correlation_id) },
+    ...row.capability == null ? {} : { capability: String(row.capability) },
+    ...row.contract_digest == null ? {} : { contract_digest: String(row.contract_digest) },
+    ...row.attention_key == null ? {} : { attention_key: String(row.attention_key) },
+    attention_required: Number(row.attention_required) === 1,
+    immediate_default: Number(row.immediate_default) === 1,
+    summary: String(row.summary),
+    ...row.approval_source === "human" || row.approval_source === "policy_auto" ? { approval_source: row.approval_source } : {},
+    ...row.worker_state == null ? {} : { worker_state: String(row.worker_state) },
+    ...row.failure_class == null ? {} : { failure_class: String(row.failure_class) },
+    ...row.expires_at == null ? {} : { expires_at: String(row.expires_at) },
+    ...row.workbench_path == null ? {} : { workbench_path: String(row.workbench_path) },
+    details,
+    payload_hash: String(row.payload_hash)
   };
+  const { payload_hash: _payloadHash, ...unsigned } = event;
+  if (event.payload_hash !== canonicalJsonDigest(unsigned)) {
+    throw new ProposalStoreError("ATTENTION_EVENT_CORRUPT", `attention event ${event.event_id} failed its integrity check`);
+  }
+  return event;
 }
-function rowToEvent(row) {
+function rowToAttentionItem(row) {
   if (!isRecord3(row)) return void 0;
+  const status = String(row.status);
+  const severity = String(row.severity);
+  const eventType = String(row.event_type);
+  if (!["open", "acknowledged", "resolved", "expired"].includes(status)) return void 0;
+  if (!["informational", "warning", "critical"].includes(severity) || !attentionEventTypes.has(eventType)) return void 0;
+  let acknowledgementIdentity;
+  if (row.acknowledgement_identity_json != null) {
+    try {
+      const parsed = JSON.parse(String(row.acknowledgement_identity_json));
+      if (!isRecord3(parsed) || !isRecord3(parsed.decision)) return void 0;
+      acknowledgementIdentity = parsed;
+    } catch {
+      return void 0;
+    }
+  }
   return {
-    event_id: Number(row.event_id),
-    proposal_id: String(row.proposal_id),
-    kind: String(row.kind),
-    actor: String(row.actor),
-    payload: JSON.parse(String(row.payload_json)),
-    created_at: String(row.created_at)
+    attention_id: String(row.attention_id),
+    attention_key: String(row.attention_key),
+    status,
+    severity,
+    environment: String(row.environment),
+    event_type: eventType,
+    capability: row.capability == null ? void 0 : String(row.capability),
+    contract_digest: row.contract_digest == null ? void 0 : String(row.contract_digest),
+    title: String(row.title),
+    occurrence_count: Number(row.occurrence_count),
+    first_event_id: String(row.first_event_id),
+    latest_event_id: String(row.latest_event_id),
+    first_seen_at: String(row.first_seen_at),
+    last_seen_at: String(row.last_seen_at),
+    acknowledged_by: row.acknowledged_by == null ? void 0 : String(row.acknowledged_by),
+    acknowledged_at: row.acknowledged_at == null ? void 0 : String(row.acknowledged_at),
+    acknowledgement_identity: acknowledgementIdentity,
+    resolved_at: row.resolved_at == null ? void 0 : String(row.resolved_at),
+    expires_at: row.expires_at == null ? void 0 : String(row.expires_at)
   };
 }
-function rowToApproval(row) {
+function rowToNotificationDelivery(row) {
   if (!isRecord3(row)) return void 0;
   const status = String(row.status);
-  if (status !== "approved" && status !== "rejected") return void 0;
+  if (![
+    "pending",
+    "leased",
+    "delivered",
+    "retry_wait",
+    "dead_letter",
+    "suppressed",
+    "batched"
+  ].includes(status)) return void 0;
   return {
-    approval_id: Number(row.approval_id),
-    proposal_id: String(row.proposal_id),
-    proposal_version: Number(row.proposal_version),
-    proposal_hash: String(row.proposal_hash),
-    approver: String(row.approver),
+    delivery_id: String(row.delivery_id),
+    sink_id: String(row.sink_id),
+    event_id: String(row.event_id),
+    ...row.attention_id == null ? {} : { attention_id: String(row.attention_id) },
     status,
-    reason: row.reason == null ? void 0 : String(row.reason),
-    identity: row.identity_json == null ? void 0 : JSON.parse(String(row.identity_json)),
-    decision_hash: row.decision_hash == null ? void 0 : String(row.decision_hash),
-    signature: row.signature == null ? void 0 : String(row.signature),
-    integrity_hash: row.integrity_hash == null ? void 0 : String(row.integrity_hash),
-    freshness_proof_digest: row.freshness_proof_digest == null ? void 0 : String(row.freshness_proof_digest),
-    created_at: String(row.created_at)
+    attempts: Number(row.attempts),
+    max_attempts: Number(row.max_attempts),
+    next_attempt_at: String(row.next_attempt_at),
+    ...row.lease_owner == null ? {} : { lease_owner: String(row.lease_owner) },
+    ...row.lease_id == null ? {} : { lease_id: String(row.lease_id) },
+    ...row.lease_expires_at == null ? {} : { lease_expires_at: String(row.lease_expires_at) },
+    ...row.last_error_code == null ? {} : { last_error_code: String(row.last_error_code) },
+    ...row.external_reference == null ? {} : { external_reference: String(row.external_reference) },
+    ...row.delivered_at == null ? {} : { delivered_at: String(row.delivered_at) },
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
   };
 }
-function rowToPolicyRecommendation(row) {
-  if (!isRecord3(row)) return void 0;
-  let unsigned;
-  try {
-    unsigned = JSON.parse(String(row.payload_json));
-  } catch {
-    throw new ProposalStoreError("POLICY_RECOMMENDATION_TAMPERED", "policy recommendation payload is not valid JSON");
-  }
-  const recommendation = { ...unsigned, integrity_hash: String(row.integrity_hash) };
-  assertPolicyRecommendationShape(recommendation);
-  if (recommendation.recommendation_id !== String(row.recommendation_id) || recommendation.tenant_id !== String(row.tenant_id) || recommendation.capability !== String(row.capability) || recommendation.policy !== String(row.policy) || recommendation.base_contract_digest !== String(row.base_contract_digest) || recommendation.status !== String(row.status)) throw new ProposalStoreError("POLICY_RECOMMENDATION_TAMPERED", `policy recommendation ${String(row.recommendation_id)} index fields do not match its signed payload`);
-  const expected = canonicalJsonDigest(policyRecommendationUnsigned(recommendation));
-  if (recommendation.integrity_hash !== expected) throw new ProposalStoreError("POLICY_RECOMMENDATION_TAMPERED", `policy recommendation ${recommendation.recommendation_id} failed its integrity check`);
-  return recommendation;
-}
-function policyRecommendationUnsigned(recommendation) {
-  const { integrity_hash: _integrityHash, ...unsigned } = recommendation;
-  return unsigned;
-}
-function assertPolicyRecommendationShape(recommendation) {
-  if (recommendation.schema_version !== "synapsor.policy-recommendation.v1") throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "unsupported policy recommendation schema version");
-  if (!/^ptr_[a-f0-9]{20}$/.test(recommendation.recommendation_id)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation id is invalid");
-  for (const [name, value] of [["tenant", recommendation.tenant_id], ["capability", recommendation.capability], ["policy", recommendation.policy], ["field", recommendation.field]]) {
-    if (!value || value.length > 256) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", `policy recommendation ${name} is invalid`);
-  }
-  if (!/^sha256:[a-f0-9]{64}$/.test(recommendation.base_contract_digest)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation base digest is invalid");
-  if (!/^sha256:[a-f0-9]{64}$/.test(recommendation.integrity_hash)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation integrity digest is invalid");
-  if (!Number.isFinite(recommendation.current_threshold) || !Number.isFinite(recommendation.proposed_threshold) || !Number.isFinite(recommendation.maximum_increment) || !Number.isFinite(recommendation.absolute_ceiling)) {
-    throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation thresholds must be finite numbers");
-  }
-  if (recommendation.proposed_threshold <= recommendation.current_threshold || recommendation.proposed_threshold - recommendation.current_threshold > recommendation.maximum_increment || recommendation.proposed_threshold > recommendation.absolute_ceiling) {
-    throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation exceeds its reviewed increment or ceiling");
-  }
-  if (!Array.isArray(recommendation.evidence_proposal_ids) || recommendation.evidence_proposal_ids.length === 0 || recommendation.evidence_proposal_ids.length > 1e4) {
-    throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation requires bounded proposal evidence");
-  }
-  if (!isRecord3(recommendation.metrics) || !isRecord3(recommendation.criteria)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation criteria and metrics are required");
-  if (!["pending_review", "approved", "rejected", "exported"].includes(recommendation.status)) throw new ProposalStoreError("POLICY_RECOMMENDATION_INVALID", "policy recommendation status is invalid");
-}
-function assertPolicyRecommendationIdentity(recommendation, input) {
-  const proof = input.identity;
-  if (!proof.verified || proof.provider === "dev_env") throw new ProposalStoreError("POLICY_RECOMMENDATION_VERIFIED_IDENTITY_REQUIRED", "policy recommendation decisions require a cryptographically verified operator identity");
-  if (proof.subject !== input.actor || proof.decision.subject !== input.actor) throw new ProposalStoreError("POLICY_RECOMMENDATION_IDENTITY_MISMATCH", "policy recommendation actor does not match the verified identity");
-  if (proof.decision.action !== input.action || proof.decision.proposal_id !== recommendation.recommendation_id || proof.decision.proposal_hash !== recommendation.integrity_hash || proof.decision.proposal_version !== 1) {
-    throw new ProposalStoreError("POLICY_RECOMMENDATION_IDENTITY_MISMATCH", "verified operator decision is not bound to this policy recommendation version");
-  }
-  const { integrity_hash: _integrityHash, ...core } = proof;
-  const canonicalCore = JSON.parse(JSON.stringify(core));
-  if (proof.integrity_hash !== canonicalJsonDigest(canonicalCore)) throw new ProposalStoreError("POLICY_RECOMMENDATION_IDENTITY_TAMPERED", "verified operator identity proof failed its integrity check");
-}
 function rowToWorkerQueueItem(row) {
   if (!isRecord3(row)) return void 0;
   const status = String(row.status);
-  if (!["queued", "leased", "retry_wait", "completed", "dead_letter", "discarded"].includes(status)) return void 0;
+  if (![
+    "queued",
+    "leased",
+    "retry_wait",
+    "completed",
+    "dead_letter",
+    "discarded",
+    "cancelled",
+    "blocked",
+    "reconciliation_required"
+  ].includes(status)) return void 0;
+  const executionMode = row.execution_mode == null ? "legacy" : String(row.execution_mode);
+  if (executionMode !== "legacy" && executionMode !== "supervised_worker") return void 0;
   return {
     proposal_id: String(row.proposal_id),
     status,
+    execution_mode: executionMode,
+    contract_digest: row.contract_digest == null ? void 0 : String(row.contract_digest),
     attempts: Number(row.attempts),
     max_attempts: Number(row.max_attempts),
     next_attempt_at: String(row.next_attempt_at),
     lease_owner: row.lease_owner == null ? void 0 : String(row.lease_owner),
+    lease_id: row.lease_id == null ? void 0 : String(row.lease_id),
     lease_expires_at: row.lease_expires_at == null ? void 0 : String(row.lease_expires_at),
     last_error_code: row.last_error_code == null ? void 0 : String(row.last_error_code),
+    terminal_outcome: row.terminal_outcome == null ? void 0 : String(row.terminal_outcome),
     created_at: String(row.created_at),
     updated_at: String(row.updated_at)
   };
 }
+function workerLeaseId(proposalId, workerId, attempt, now) {
+  const prefixLength = "sha256:".length;
+  return `wlease_${canonicalJsonDigest({ proposal_id: proposalId, worker_id: workerId, attempt, now }).slice(prefixLength, prefixLength + 32)}`;
+}
 function rowToCloudOutboxItem(row) {
   if (!isRecord3(row)) return void 0;
   const kind = String(row.kind);
@@ -9943,7 +12718,17 @@ function rowToWritebackIntent(row) {
   };
 }
 function isStoredWritebackOperation(operation) {
-  return ["single_row_update", "single_row_insert", "single_row_delete", "set_update", "set_delete", "batch_insert"].includes(operation);
+  return [
+    "single_row_update",
+    "single_row_insert",
+    "single_row_delete",
+    "set_update",
+    "set_delete",
+    "batch_insert",
+    "restore_update",
+    "remove_insert",
+    "restore_insert"
+  ].includes(operation);
 }
 function rowToQueryAudit(row) {
   if (!isRecord3(row)) return void 0;
@@ -10054,7 +12839,9 @@ var sharedLedgerJsonColumns = /* @__PURE__ */ new Set([
   "patch_json",
   "selected_capabilities_json",
   "proposed_effect_json",
-  "actual_effect_json"
+  "actual_effect_json",
+  "details_json",
+  "acknowledgement_identity_json"
 ]);
 var sharedLedgerKindToTable = {
   proposal: "proposals",
@@ -10073,6 +12860,9 @@ var sharedLedgerKindToTable = {
   shadow_study_case: "shadow_study_cases",
   shadow_outcome: "shadow_outcomes",
   worker_queue_item: "worker_queue",
+  attention_event: "attention_events",
+  attention_item: "attention_items",
+  notification_delivery: "notification_deliveries",
   runner_state: "runner_state",
   policy_recommendation: "policy_recommendations",
   cloud_outbox_event: "cloud_outbox",
@@ -10115,7 +12905,142 @@ var sharedLedgerRestoreSpecs = {
   shadow_studies: restoreSpec("study_id", ["study_id", "name", "description", "selected_capabilities_json", "starts_at", "ends_at", "status", "created_at", "updated_at"], ["study_id", "name", "selected_capabilities_json", "status", "created_at", "updated_at"]),
   shadow_study_cases: restoreSpec("case_id", ["case_id", "study_id", "request_id", "proposal_id", "tenant_id", "principal", "capability", "business_object", "object_id", "evidence_bundle_id", "proposed_effect_json", "agent_result", "decision_reason", "risk_score", "amount_value", "created_at"], ["case_id", "study_id", "request_id", "tenant_id", "capability", "business_object", "object_id", "agent_result", "created_at"]),
   shadow_outcomes: restoreSpec("outcome_id", ["outcome_id", "study_id", "request_id", "proposal_id", "tenant_id", "business_object", "object_id", "actor", "disposition", "actual_effect_json", "occurred_at", "source", "reference", "reason", "created_at"], ["outcome_id", "study_id", "request_id", "tenant_id", "business_object", "object_id", "actor", "disposition", "occurred_at", "source", "created_at"]),
-  worker_queue: restoreSpec("proposal_id", ["proposal_id", "status", "attempts", "max_attempts", "next_attempt_at", "lease_owner", "lease_expires_at", "last_error_code", "created_at", "updated_at"], ["proposal_id", "status", "attempts", "max_attempts", "next_attempt_at", "created_at", "updated_at"]),
+  worker_queue: restoreSpec(
+    "proposal_id",
+    [
+      "proposal_id",
+      "status",
+      "execution_mode",
+      "contract_digest",
+      "attempts",
+      "max_attempts",
+      "next_attempt_at",
+      "lease_owner",
+      "lease_id",
+      "lease_expires_at",
+      "last_error_code",
+      "terminal_outcome",
+      "created_at",
+      "updated_at"
+    ],
+    ["proposal_id", "status", "attempts", "max_attempts", "next_attempt_at", "created_at", "updated_at"]
+  ),
+  attention_events: restoreSpec(
+    "event_id",
+    [
+      "event_id",
+      "schema_version",
+      "event_type",
+      "severity",
+      "occurred_at",
+      "environment",
+      "proposal_id",
+      "job_id",
+      "operation_id",
+      "correlation_id",
+      "capability",
+      "contract_digest",
+      "attention_key",
+      "attention_required",
+      "immediate_default",
+      "summary",
+      "approval_source",
+      "worker_state",
+      "failure_class",
+      "expires_at",
+      "workbench_path",
+      "details_json",
+      "payload_hash",
+      "created_at"
+    ],
+    [
+      "event_id",
+      "schema_version",
+      "event_type",
+      "severity",
+      "occurred_at",
+      "environment",
+      "attention_required",
+      "immediate_default",
+      "summary",
+      "details_json",
+      "payload_hash",
+      "created_at"
+    ]
+  ),
+  attention_items: restoreSpec(
+    "attention_id",
+    [
+      "attention_id",
+      "attention_key",
+      "status",
+      "severity",
+      "environment",
+      "event_type",
+      "capability",
+      "contract_digest",
+      "title",
+      "occurrence_count",
+      "first_event_id",
+      "latest_event_id",
+      "first_seen_at",
+      "last_seen_at",
+      "acknowledged_by",
+      "acknowledged_at",
+      "acknowledgement_identity_json",
+      "acknowledgement_decision_hash",
+      "acknowledgement_signature",
+      "acknowledgement_integrity_hash",
+      "resolved_at",
+      "expires_at"
+    ],
+    [
+      "attention_id",
+      "attention_key",
+      "status",
+      "severity",
+      "environment",
+      "event_type",
+      "title",
+      "occurrence_count",
+      "first_event_id",
+      "latest_event_id",
+      "first_seen_at",
+      "last_seen_at"
+    ]
+  ),
+  notification_deliveries: restoreSpec(
+    "delivery_id",
+    [
+      "delivery_id",
+      "sink_id",
+      "event_id",
+      "attention_id",
+      "status",
+      "attempts",
+      "max_attempts",
+      "next_attempt_at",
+      "lease_owner",
+      "lease_id",
+      "lease_expires_at",
+      "last_error_code",
+      "external_reference",
+      "delivered_at",
+      "created_at",
+      "updated_at"
+    ],
+    [
+      "delivery_id",
+      "sink_id",
+      "event_id",
+      "status",
+      "attempts",
+      "max_attempts",
+      "next_attempt_at",
+      "created_at",
+      "updated_at"
+    ]
+  ),
   runner_state: restoreSpec("key", ["key", "value_json", "updated_at"], ["key", "value_json", "updated_at"]),
   policy_recommendations: restoreSpec("recommendation_id", ["recommendation_id", "tenant_id", "capability", "policy", "base_contract_digest", "status", "payload_json", "integrity_hash", "created_at", "updated_at"], ["recommendation_id", "tenant_id", "capability", "policy", "base_contract_digest", "status", "payload_json", "integrity_hash", "created_at", "updated_at"]),
   cloud_outbox: restoreSpec("event_id", ["event_id", "proposal_id", "sequence", "kind", "status", "payload_hash", "payload_json", "attempts", "max_attempts", "next_attempt_at", "lease_owner", "lease_expires_at", "last_error_code", "sent_at", "acknowledged_at", "created_at", "updated_at"], ["event_id", "sequence", "kind", "status", "payload_hash", "payload_json", "attempts", "max_attempts", "next_attempt_at", "created_at", "updated_at"]),
@@ -10164,6 +13089,9 @@ function sharedLedgerRestoreRank(entry) {
     "shadow_human_actions",
     "shadow_outcomes",
     "worker_queue",
+    "attention_events",
+    "attention_items",
+    "notification_deliveries",
     "runner_state",
     "policy_recommendations",
     "cloud_outbox",
@@ -10478,6 +13406,214 @@ function isRecord3(value) {
 // packages/schema-inspector/src/index.ts
 import mysql from "mysql2/promise";
 import { Pool as Pool2 } from "pg";
+
+// packages/schema-inspector/src/sensitivity.ts
+var HIGH_CONFIDENCE_RULES = [
+  rule(
+    "credential_or_secret",
+    "The field name or description indicates credentials, authentication material, or a secret.",
+    [
+      "password",
+      "passwordhash",
+      "passwd",
+      "passphrase",
+      "secret",
+      "token",
+      "apikey",
+      "accesskey",
+      "privatekey",
+      "credential",
+      "oauth",
+      "cookie",
+      "sessiontoken"
+    ]
+  ),
+  rule(
+    "payment_or_bank_detail",
+    "The field name or description indicates a payment instrument or bank detail.",
+    [
+      "paymentmethod",
+      "paymentinstrument",
+      "paymentdetails",
+      "cardnumber",
+      "creditcard",
+      "debitcard",
+      "cardtoken",
+      "cvv",
+      "cvc",
+      "bankaccount",
+      "accountnumber",
+      "routingnumber",
+      "iban",
+      "swiftcode"
+    ]
+  ),
+  rule(
+    "government_identifier",
+    "The field name or description indicates a government-issued or tax identifier.",
+    [
+      "ssn",
+      "socialsecurity",
+      "socialsecuritynumber",
+      "taxid",
+      "nationalid",
+      "passport",
+      "passportnumber",
+      "driverslicense",
+      "driverlicense"
+    ]
+  ),
+  rule(
+    "birth_information",
+    "The field name or description indicates a date of birth or birth information.",
+    ["dateofbirth", "birthdate", "dob"]
+  ),
+  rule(
+    "medical_or_health_information",
+    "The field name or description indicates medical or health information.",
+    [
+      "medical",
+      "health",
+      "diagnosis",
+      "treatment",
+      "medication",
+      "prescription",
+      "allergy",
+      "clinical",
+      "patientnote",
+      "waivernote"
+    ]
+  ),
+  rule(
+    "direct_contact_or_address",
+    "The field name or description indicates direct contact or address information.",
+    [
+      "email",
+      "emailaddress",
+      "phone",
+      "phonenumber",
+      "telephone",
+      "streetaddress",
+      "homeaddress",
+      "mailingaddress",
+      "postalcode",
+      "zipcode"
+    ]
+  ),
+  rule(
+    "biometric_or_precise_location",
+    "The field name or description indicates biometric or precise-location information.",
+    [
+      "biometric",
+      "fingerprint",
+      "faceprint",
+      "voiceprint",
+      "geolocation",
+      "gpscoordinate",
+      "latitude",
+      "longitude",
+      "preciselocation"
+    ]
+  ),
+  rule(
+    "private_or_risk_information",
+    "The field name or description indicates private notes, internal risk data, or a risk score.",
+    ["privatenote", "privatedata", "internalrisk", "riskscore"]
+  )
+];
+var UNRESOLVED_NAME_TOKENS = /* @__PURE__ */ new Set([
+  "note",
+  "notes",
+  "comment",
+  "comments",
+  "description",
+  "memo",
+  "message",
+  "payload",
+  "body",
+  "content",
+  "details",
+  "remarks",
+  "metadata",
+  "freeform"
+]);
+var UNRESOLVED_DATA_TYPES = /* @__PURE__ */ new Set(["json", "jsonb", "xml", "object", "array"]);
+function classifySensitivity(input) {
+  const evidence = normalizeEvidence(input);
+  const matched = HIGH_CONFIDENCE_RULES.filter((candidate) => candidate.matches(evidence));
+  if (input.writeOnly) {
+    matched.push({
+      code: "write_only_input",
+      reason: "The source marks this field as write-only, so it must not become model-visible.",
+      matches: () => true
+    });
+  }
+  if (matched.length > 0) {
+    return classification(
+      "high_confidence_sensitive",
+      matched.map((item) => item.code),
+      matched.map((item) => item.reason),
+      input.source
+    );
+  }
+  const unresolved = [];
+  if ([...evidence.tokens].some((token) => UNRESOLVED_NAME_TOKENS.has(token))) {
+    unresolved.push({
+      code: "unconstrained_free_text_name",
+      reason: "The field name indicates unconstrained notes, comments, descriptions, or payload content."
+    });
+  }
+  if (UNRESOLVED_DATA_TYPES.has(evidence.dataType)) {
+    unresolved.push({
+      code: "unstructured_data_type",
+      reason: `The ${evidence.dataType} data type can contain unreviewed nested or free-form content.`
+    });
+  }
+  if (unresolved.length > 0) {
+    return classification(
+      "unresolved_free_text",
+      unresolved.map((item) => item.code),
+      unresolved.map((item) => item.reason),
+      input.source
+    );
+  }
+  return classification(
+    "structurally_low_risk",
+    ["no_sensitive_structural_signal"],
+    ["No deterministic sensitive or unconstrained free-text signal was found in the available structural metadata."],
+    input.source
+  );
+}
+function classification(state, reasonCodes, reasons, evidenceSource) {
+  return {
+    state,
+    reason_codes: [...new Set(reasonCodes)].sort(),
+    reasons: [...new Set(reasons)].sort(),
+    evidence_source: evidenceSource
+  };
+}
+function rule(code, reason, patterns) {
+  return {
+    code,
+    reason,
+    matches: (value) => patterns.some((pattern) => value.compact.includes(pattern) || value.descriptionCompact.includes(pattern))
+  };
+}
+function normalizeEvidence(input) {
+  const identifier = splitIdentifier(input.name);
+  const description = splitIdentifier(input.description ?? "");
+  return {
+    compact: identifier.replaceAll("_", ""),
+    tokens: new Set(identifier.split("_").filter(Boolean)),
+    descriptionCompact: description.replaceAll("_", ""),
+    dataType: String(input.dataType ?? "").trim().toLowerCase()
+  };
+}
+function splitIdentifier(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+
+// packages/schema-inspector/src/index.ts
 function schemaFingerprintForInspection(inspection) {
   return canonicalJsonDigest({
     engine: inspection.engine,
@@ -10536,30 +13672,6 @@ function rolePostureFingerprint(inspection) {
 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"]);
-var SENSITIVE_PATTERNS = [
-  /password/i,
-  /password_hash/i,
-  /secret/i,
-  /token/i,
-  /api[_-]?key/i,
-  /access[_-]?key/i,
-  /private[_-]?key/i,
-  /session/i,
-  /cookie/i,
-  /\bssn\b/i,
-  /social[_-]?security/i,
-  /credit[_-]?card/i,
-  /card[_-]?number/i,
-  /\bcvv\b/i,
-  /refresh[_-]?token/i,
-  /oauth/i,
-  /(?:^|[_-])email(?:$|[_-])/i,
-  /(?:^|[_-])phone(?:$|[_-])/i,
-  /(?:^|[_-])(?:street_)?address(?:$|[_-])/i,
-  /(?:^|[_-])(?:date_of_birth|birth_date|dob)(?:$|[_-])/i,
-  /(?:^|[_-])risk[_-]?score(?:$|[_-])/i,
-  /(?:^|[_-])private[_-]?(?:note|notes|data)(?:$|[_-])/i
-];
 var LARGE_OR_BINARY_TYPES = /* @__PURE__ */ new Set([
   "bytea",
   "blob",
@@ -10877,20 +13989,26 @@ async function inspectMysql(options) {
       [schemaParam, schemaParam]
     );
     const [grantRows] = await connection.query("SHOW GRANTS FOR CURRENT_USER");
-    const mysqlRole = mysqlRolePosture(grantRows.map((row) => String(Object.values(row)[0] ?? "")));
+    const mysqlGrants = mysqlGrantPosture(
+      grantRows.map((row) => String(Object.values(row)[0] ?? "")),
+      tableRows.map((row) => ({
+        schema: String(row.schema),
+        table: String(row.name)
+      }))
+    );
     const relationRolePosture = tableRows.map((row) => ({
       schema: String(row.schema),
       table_name: String(row.name),
       owner: "",
       current_role_is_owner: false,
       current_role_can_assume_owner: false,
-      can_select: mysqlRole.canSelect,
-      can_insert: mysqlRole.canWrite,
-      can_update: mysqlRole.canWrite,
-      can_delete: mysqlRole.canWrite,
-      can_truncate: mysqlRole.canWrite,
-      can_references: mysqlRole.canWrite,
-      can_trigger: mysqlRole.canWrite,
+      can_select: mysqlGrants.relations[`${String(row.schema)}.${String(row.name)}`]?.select ?? false,
+      can_insert: mysqlGrants.relations[`${String(row.schema)}.${String(row.name)}`]?.insert ?? false,
+      can_update: mysqlGrants.relations[`${String(row.schema)}.${String(row.name)}`]?.update ?? false,
+      can_delete: mysqlGrants.relations[`${String(row.schema)}.${String(row.name)}`]?.delete ?? false,
+      can_truncate: mysqlGrants.relations[`${String(row.schema)}.${String(row.name)}`]?.truncate ?? false,
+      can_references: mysqlGrants.relations[`${String(row.schema)}.${String(row.name)}`]?.references ?? false,
+      can_trigger: mysqlGrants.relations[`${String(row.schema)}.${String(row.name)}`]?.trigger ?? false,
       row_security_forced: false
     }));
     await connection.query("COMMIT").catch(() => void 0);
@@ -10899,8 +14017,8 @@ async function inspectMysql(options) {
       server_version: String(versionRows[0]?.version ?? "unknown"),
       current_user: String(versionRows[0]?.current_user ?? "unknown"),
       role: {
-        verified: true,
-        superuser: "unsupported",
+        verified: mysqlGrants.verified,
+        superuser: mysqlGrants.elevated ? true : "unsupported",
         bypass_rls: "unsupported"
       },
       schemas: schemaRows.map((row) => String(row.schema_name)),
@@ -11028,6 +14146,12 @@ function normalizeColumn(column, primaryKey) {
   const name = String(column.name);
   const lower = name.toLowerCase();
   const type = String(column.udt_name || column.data_type || "unknown").toLowerCase();
+  const sensitivity = classifySensitivity({
+    name,
+    dataType: String(column.data_type || column.udt_name || "unknown"),
+    description: column.comment ?? void 0,
+    source: "database"
+  });
   return {
     name,
     data_type: String(column.data_type || column.udt_name || "unknown"),
@@ -11041,7 +14165,8 @@ function normalizeColumn(column, primaryKey) {
     suggestions: {
       tenant: TENANT_COLUMNS.has(lower),
       conflict: CONFLICT_COLUMNS.has(lower),
-      sensitive: SENSITIVE_PATTERNS.some((pattern) => pattern.test(lower)),
+      sensitive: sensitivity.state !== "structurally_low_risk",
+      sensitivity,
       immutable: primaryKey.includes(name) || TENANT_COLUMNS.has(lower) || IMMUTABLE_COLUMNS.has(lower),
       large_or_binary: LARGE_OR_BINARY_TYPES.has(type) || /blob|binary|bytea|vector/i.test(type)
     }
@@ -11073,13 +14198,139 @@ function relationIsWriteCapable(table) {
   if (!privileges) return true;
   return privileges.insert || privileges.update || privileges.delete || privileges.truncate || privileges.trigger;
 }
-function mysqlRolePosture(grants) {
-  const normalized = grants.map((grant) => grant.toUpperCase());
-  const canSelect = normalized.some((grant) => /\bGRANT\b[\s\S]*\b(?:SELECT|ALL PRIVILEGES)\b/.test(grant));
-  const canWrite = normalized.some(
-    (grant) => /\bGRANT\b[\s\S]*\b(?:ALL PRIVILEGES|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRIGGER|EXECUTE|CREATE VIEW)\b/.test(grant)
-  );
-  return { canSelect, canWrite };
+function mysqlGrantPosture(grants, relations) {
+  const parsed = [];
+  let verified = true;
+  let elevated = false;
+  for (const raw of grants) {
+    const grant = raw.trim();
+    const match = grant.match(/^GRANT\s+(.+?)\s+ON\s+(.+?)\s+TO\s+/i);
+    if (!match) {
+      if (/^GRANT\s+/i.test(grant)) verified = false;
+      continue;
+    }
+    const target = parseMysqlGrantTarget(match[2]);
+    const privileges = parseMysqlGrantPrivileges(match[1]);
+    if (!target || !privileges.verified) {
+      verified = false;
+      continue;
+    }
+    elevated ||= privileges.elevated || /\bWITH\s+GRANT\s+OPTION\b/i.test(grant);
+    parsed.push({
+      ...target,
+      privileges: privileges.relation
+    });
+  }
+  const relationMap = {};
+  for (const relation of relations) {
+    const posture = {
+      select: false,
+      insert: false,
+      update: false,
+      delete: false,
+      truncate: false,
+      references: false,
+      trigger: false
+    };
+    for (const grant of parsed) {
+      if ((grant.schema === "*" || grant.schema === relation.schema) && (grant.table === "*" || grant.table === relation.table)) {
+        for (const privilege of Object.keys(posture)) {
+          posture[privilege] ||= grant.privileges[privilege];
+        }
+      }
+    }
+    relationMap[`${relation.schema}.${relation.table}`] = posture;
+  }
+  return { verified, elevated, relations: relationMap };
+}
+function parseMysqlGrantTarget(value) {
+  const identifier = String.raw`(?:\*|` + "`(?:``|[^`])+`" + String.raw`|[A-Za-z0-9_$-]+)`;
+  const match = value.trim().match(new RegExp(`^(${identifier})\\s*\\.\\s*(${identifier})$`));
+  if (!match) return void 0;
+  return {
+    schema: unquoteMysqlGrantIdentifier(match[1]),
+    table: unquoteMysqlGrantIdentifier(match[2])
+  };
+}
+function unquoteMysqlGrantIdentifier(value) {
+  if (value === "*") return value;
+  return value.startsWith("`") && value.endsWith("`") ? value.slice(1, -1).replaceAll("``", "`") : value;
+}
+function parseMysqlGrantPrivileges(value) {
+  const relation = {
+    select: false,
+    insert: false,
+    update: false,
+    delete: false,
+    truncate: false,
+    references: false,
+    trigger: false
+  };
+  const normalized = value.replace(/\([^)]*\)/g, "").split(",").map((entry) => entry.trim().replace(/\s+/g, " ").toUpperCase()).filter(Boolean);
+  const allowed = /* @__PURE__ */ new Set([
+    "USAGE",
+    "SELECT",
+    "INSERT",
+    "UPDATE",
+    "DELETE",
+    "REFERENCES",
+    "TRIGGER",
+    "ALL",
+    "ALL PRIVILEGES"
+  ]);
+  const elevatedPrivileges = /* @__PURE__ */ new Set([
+    "ALTER",
+    "ALTER ROUTINE",
+    "CREATE",
+    "CREATE ROLE",
+    "CREATE ROUTINE",
+    "CREATE TABLESPACE",
+    "CREATE TEMPORARY TABLES",
+    "CREATE USER",
+    "CREATE VIEW",
+    "DROP",
+    "EVENT",
+    "EXECUTE",
+    "FILE",
+    "GRANT OPTION",
+    "INDEX",
+    "LOCK TABLES",
+    "PROCESS",
+    "RELOAD",
+    "REPLICATION CLIENT",
+    "REPLICATION SLAVE",
+    "SHOW DATABASES",
+    "SHOW VIEW",
+    "SHUTDOWN",
+    "SUPER",
+    "SYSTEM_USER"
+  ]);
+  let verified = true;
+  let elevated = false;
+  for (const privilege of normalized) {
+    const all = privilege === "ALL" || privilege === "ALL PRIVILEGES";
+    if (all) {
+      relation.select = true;
+      relation.insert = true;
+      relation.update = true;
+      relation.delete = true;
+      relation.truncate = true;
+      relation.references = true;
+      relation.trigger = true;
+      elevated = true;
+      continue;
+    }
+    if (privilege === "SELECT") relation.select = true;
+    else if (privilege === "INSERT") relation.insert = true;
+    else if (privilege === "UPDATE") relation.update = true;
+    else if (privilege === "DELETE") relation.delete = true;
+    else if (privilege === "REFERENCES") relation.references = true;
+    else if (privilege === "TRIGGER") relation.trigger = true;
+    else if (privilege === "DROP") relation.truncate = true;
+    if (elevatedPrivileges.has(privilege)) elevated = true;
+    else if (!allowed.has(privilege)) verified = false;
+  }
+  return { verified, elevated, relation };
 }
 function constraintColumns(rows, kind) {
   const grouped = groupBy(rows.filter((row) => row.constraint_type === kind), (row) => row.constraint_name);
@@ -13204,6 +16455,51 @@ function asRecord(value) {
 }
 
 // packages/mcp-server/src/index.ts
+function resolveSupervisedWorkerEligibility(config, capability, options = {}) {
+  const reasons = [];
+  const deployment = config.supervised_worker;
+  const digest = capability.contract_provenance?.digest;
+  if (!deployment?.enabled) reasons.push("deployment_disabled");
+  if (config.mode !== "review") reasons.push("review_mode_required");
+  if (config.governance?.mode === "cloud_linked") reasons.push("cloud_linked_local_execution_forbidden");
+  if (capability.kind !== "proposal") reasons.push("proposal_capability_required");
+  if (capability.execution?.supervised_worker !== "allowed") reasons.push("contract_permission_missing");
+  if (!digest) reasons.push("active_contract_digest_missing");
+  const policy = digest ? deployment?.capabilities.find((entry) => entry.capability === capability.name && entry.contract_digest === digest && entry.mode === "supervised_worker") : void 0;
+  if (!policy) reasons.push("deployment_allowlist_mismatch");
+  if (options.phase !== "queue" && policy?.worker_identity && policy.worker_identity !== options.workerIdentity) {
+    reasons.push("worker_identity_mismatch");
+  }
+  const source = config.sources?.[capability.source];
+  if (!source || source.read_only === true || !source.write_url_env) {
+    reasons.push("writable_source_unavailable");
+  } else {
+    if (policy && policy.write_url_env !== source.write_url_env) reasons.push("writer_reference_mismatch");
+    if (!source.receipts) reasons.push("receipt_authority_missing");
+  }
+  if (!capability.target.tenant_key) reasons.push("trusted_tenant_scope_missing");
+  if (capability.writeback?.mode !== "direct_sql") reasons.push("direct_sql_required");
+  if ((capability.operation?.cardinality ?? "single") !== "single") reasons.push("single_row_required");
+  const operation = capability.operation?.kind ?? "update";
+  if (operation === "delete") reasons.push("delete_ineligible");
+  if (capability.reversibility) reasons.push("reversibility_ineligible");
+  if (operation === "update" && (!capability.conflict_guard?.column || capability.conflict_guard.weak_guard_ack === true)) {
+    reasons.push("exact_conflict_guard_required");
+  }
+  if (operation === "insert" && !capability.operation?.deduplication?.components.length) {
+    reasons.push("insert_deduplication_required");
+  }
+  const uniqueReasons = [...new Set(reasons)];
+  return {
+    eligible: uniqueReasons.length === 0,
+    code: uniqueReasons.length === 0 ? "SUPERVISED_WORKER_ELIGIBLE" : uniqueReasons[0].toUpperCase(),
+    reasons: uniqueReasons,
+    capability: capability.name,
+    ...digest ? { contract_digest: digest } : {},
+    ...deployment ? { profile: deployment.profile } : {},
+    ...policy ? { policy } : {}
+  };
+}
 function describeIsolationAssurance(config) {
   return Object.entries(config.sources ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([sourceName, source]) => {
     const providers = trustedContextProvidersForSource(config, sourceName);
@@ -13744,8 +17040,8 @@ var CloudLinkedSynchronizer = class {
         acknowledged += 1;
       } catch (error) {
         failed += 1;
-        const classification = classifyCloudSyncFailure(error);
-        await this.store.failCloudOutbox({ event_id: item.event_id, owner: this.owner, ...classification });
+        const classification2 = classifyCloudSyncFailure(error);
+        await this.store.failCloudOutbox({ event_id: item.event_id, owner: this.owner, ...classification2 });
       }
     }
     await this.reconcileOnce().catch((error) => {
@@ -13979,6 +17275,7 @@ function runtimeCapabilityFromSpec(capability, resources, config, provenance) {
     runtime.operation = capability.proposal.operation;
     runtime.conflict_guard = capability.proposal.conflict_guard;
     runtime.approval = capability.proposal.approval;
+    runtime.execution = capability.proposal.execution;
     runtime.writeback = {
       mode: capability.proposal.writeback?.mode ?? "direct_sql",
       ...capability.proposal.writeback?.executor ? { executor: capability.proposal.writeback.executor } : {}
@@ -14024,7 +17321,7 @@ function createMcpRuntime(config, options = {}) {
   return {
     config,
     store,
-    listTools: () => config.mode === "cloud" ? cloudTools : listedLocalCapabilities(config).map((capability) => toolMetadata(capability)),
+    listTools: () => config.mode === "cloud" ? cloudTools : listedLocalCapabilities(config).map((capability) => toolMetadata(capability, config)),
     callTool: async (name, args) => {
       const capability = config.mode === "cloud" ? void 0 : localCapabilities(config).find((item) => item.name === name);
       try {
@@ -14133,6 +17430,8 @@ async function preflightPostgresDatabaseScope(inputConfig, env = process.env, cr
     }
   }
 }
+var SUPPORTED_GENERATED_AUTHORITY_COMPILER_VERSIONS = /* @__PURE__ */ new Set(["1.6.0", "1.6.3"]);
+var SUPPORTED_GENERATED_AUTHORITY_SPEC_VERSIONS = /* @__PURE__ */ new Set(["1.5.0", "1.5.1", "1.6.0"]);
 async function preflightGeneratedAuthority(inputConfig, env = process.env, inspect = inspectDatabase) {
   const config = resolveRuntimeConfig(inputConfig);
   const protectedCapabilities = localCapabilities(config).filter((capability) => capability.protected_read);
@@ -14198,7 +17497,7 @@ async function preflightGeneratedAuthority(inputConfig, env = process.env, inspe
 }
 function assertGeneratedAuthorityLockShape(value) {
   const digest = /^sha256:[a-f0-9]{64}$/;
-  if (!value || value.schema_version !== "synapsor.generation-lock.v1" || value.compiler_version !== "1.6.0" || value.spec_version !== "1.5.0" || value.engine !== "postgres" && value.engine !== "mysql" || !/^[A-Z_][A-Z0-9_]*$/.test(value.source_env) || !digest.test(value.schema_fingerprint) || !digest.test(value.role_posture_fingerprint) || !digest.test(value.evidence_fingerprint) || !digest.test(value.generated_contract_digest) || !digest.test(value.reviewed_overrides_digest) || !Array.isArray(value.protected_authority) || value.protected_authority.some((item) => typeof item !== "string")) {
+  if (!value || value.schema_version !== "synapsor.generation-lock.v1" || !SUPPORTED_GENERATED_AUTHORITY_COMPILER_VERSIONS.has(value.compiler_version) || !SUPPORTED_GENERATED_AUTHORITY_SPEC_VERSIONS.has(value.spec_version) || value.engine !== "postgres" && value.engine !== "mysql" || !/^[A-Z_][A-Z0-9_]*$/.test(value.source_env) || !digest.test(value.schema_fingerprint) || !digest.test(value.role_posture_fingerprint) || !digest.test(value.evidence_fingerprint) || !digest.test(value.generated_contract_digest) || !digest.test(value.reviewed_overrides_digest) || !Array.isArray(value.protected_authority) || value.protected_authority.some((item) => typeof item !== "string")) {
     throw new McpRuntimeError(
       "GENERATION_LOCK_INVALID",
       "The generated-authority lock is malformed or belongs to an unsupported compiler/spec version."
@@ -14291,7 +17590,7 @@ function createSynapsorMcpServer(runtime, options = {}) {
       for (const exposedName of exposedNames.get(capability.name) ?? [capability.name]) {
         const toolConfig = {
           title: capability.name,
-          description: capabilityDescription(capability, exposedName),
+          description: capabilityDescription(capability, runtime.config, exposedName),
           inputSchema: zodInputShape(capability),
           annotations: {
             readOnlyHint: capability.kind === "read" || capability.kind === "aggregate_read",
@@ -15955,6 +19254,31 @@ async function callConfiguredTool(input) {
       }
     });
   }
+  let supervisedWorker;
+  if (input.config.governance?.mode !== "cloud_linked" && approvalResult.proposal.state === "approved") {
+    const eligibility = resolveSupervisedWorkerEligibility(input.config, capability, { phase: "queue" });
+    if (eligibility.eligible && eligibility.policy && eligibility.contract_digest) {
+      if (!input.store.enqueueWorkerProposal) {
+        throw new McpRuntimeError(
+          "SUPERVISED_WORKER_LEDGER_REQUIRED",
+          "Supervised execution requires a durable worker queue in the authoritative proposal store."
+        );
+      }
+      await input.store.enqueueWorkerProposal({
+        proposal_id: approvalResult.proposal.proposal_id,
+        execution_mode: "supervised_worker",
+        contract_digest: eligibility.contract_digest,
+        max_attempts: eligibility.policy.max_attempts,
+        queue_limit: eligibility.policy.queue_limit
+      });
+      supervisedWorker = {
+        status: "queued",
+        mode: "supervised_worker",
+        capability: capability.name,
+        contract_digest: eligibility.contract_digest
+      };
+    }
+  }
   await enqueueCloudLinkedProposal({
     config: input.config,
     store: input.store,
@@ -15964,7 +19288,7 @@ async function callConfiguredTool(input) {
     env: input.env
   });
   return {
-    status: input.config.governance?.mode === "cloud_linked" ? "pending_cloud_sync" : input.config.mode === "shadow" ? "shadow_proposal_created" : approvalResult.freshness?.status === "stale" ? "freshness_conflict" : approvalResult.proposal.state === "approved" ? "approved" : "review_required",
+    status: input.config.governance?.mode === "cloud_linked" ? "pending_cloud_sync" : input.config.mode === "shadow" ? "shadow_proposal_created" : approvalResult.freshness?.status === "stale" ? "freshness_conflict" : supervisedWorker ? "queued_for_trusted_execution" : approvalResult.proposal.state === "approved" ? "approved" : "review_required",
     action: capability.name,
     proposal_id: approvalResult.proposal.proposal_id,
     proposal_version: approvalResult.proposal.proposal_version,
@@ -15992,6 +19316,13 @@ async function callConfiguredTool(input) {
     ...approvalResult.freshness ? { freshness: approvalResult.freshness } : {},
     governance: input.config.governance?.mode === "cloud_linked" ? { authority: "synapsor_cloud", state: "pending_cloud_sync", evidence_residency: "metadata_only" } : { authority: "local" },
     writeback: changeSet.writeback,
+    ...supervisedWorker ? {
+      execution: {
+        ...supervisedWorker,
+        approval_source: "policy_auto",
+        model_can_approve_or_apply: false
+      }
+    } : {},
     source_database_changed: false,
     source_database_mutated: false
   };
@@ -16525,9 +19856,9 @@ function approvalPolicyByName(config, 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;
+  for (const rule2 of policy.rules ?? []) {
+    const field = typeof rule2.field === "string" ? rule2.field : void 0;
+    const max = typeof rule2.max === "number" && Number.isInteger(rule2.max) ? rule2.max : void 0;
     if (field && max !== void 0) ruleByField.set(field, max);
   }
   const numericFields = Object.keys(patch).filter((field) => isNumericRuntimeProposalField(capability, field));
@@ -17517,10 +20848,10 @@ var RuntimeRateLimiter = class {
   sharedSchema;
   migration;
   async consume(context, capability) {
-    const rule = this.config.rate_limits?.capabilities?.[capability] ?? this.config.rate_limits?.default;
-    if (!rule) return;
+    const rule2 = this.config.rate_limits?.capabilities?.[capability] ?? this.config.rate_limits?.default;
+    if (!rule2) return;
     const now = this.clock();
-    const windowMs = rule.window_seconds * 1e3;
+    const windowMs = rule2.window_seconds * 1e3;
     const windowStart = Math.floor(now / windowMs) * windowMs;
     let count;
     if (this.sharedPool && this.sharedSchema) {
@@ -17536,7 +20867,7 @@ var RuntimeRateLimiter = class {
         [bucketKey, windowStart]
       );
       count = Number(result.rows[0]?.request_count ?? 0);
-      if (count > rule.requests) {
+      if (count > rule2.requests) {
         await this.sharedPool.query(
           `UPDATE ${table} SET rejected_count = rejected_count + 1, updated_at = now() WHERE bucket_key = $1 AND window_start = $2`,
           [bucketKey, windowStart]
@@ -17550,7 +20881,7 @@ var RuntimeRateLimiter = class {
       this.local.set(key, bucket);
       count = bucket.count;
     }
-    if (count <= rule.requests) return;
+    if (count <= rule2.requests) return;
     const retryAfterMs = Math.max(1, windowStart + windowMs - now);
     const metricKey = `${context.tenant_id}\0${capability}`;
     const metric = this.rejected.get(metricKey) ?? { tenant: context.tenant_id, capability, rejected: 0 };
@@ -18100,11 +21431,11 @@ function zodScalarArg(spec) {
   if (spec.required === false) schema = schema.optional();
   return schema;
 }
-function toolMetadata(capability) {
+function toolMetadata(capability, config) {
   return {
     name: capability.name,
     title: capability.name,
-    description: capabilityDescription(capability),
+    description: capabilityDescription(capability, config),
     kind: capability.kind,
     input_schema: Object.fromEntries(Object.entries(capability.args).map(([name, spec]) => [name, {
       type: spec.type === "object_array" ? "array" : spec.type,
@@ -18127,7 +21458,7 @@ function toolMetadata(capability) {
     }
   };
 }
-function capabilityDescription(capability, exposedName) {
+function capabilityDescription(capability, config, exposedName) {
   const lines = [];
   if (exposedName && exposedName !== capability.name) {
     lines.push(`Canonical Synapsor capability: ${capability.name}.`);
@@ -18137,7 +21468,20 @@ function capabilityDescription(capability, exposedName) {
   } else if (capability.kind === "read") {
     lines.push(`Read ${capability.target.schema}.${capability.target.table} through a reviewed Synapsor capability with trusted tenant context and evidence.`);
   } else {
-    lines.push(`Create an evidence-backed Synapsor proposal for ${capability.target.schema}.${capability.target.table}; the source database is not mutated by this tool.`);
+    const supervised = config ? resolveSupervisedWorkerEligibility(config, capability, { phase: "queue" }) : void 0;
+    if (supervised?.eligible) {
+      if (capability.approval?.mode === "policy") {
+        lines.push(
+          `Create an evidence-backed Synapsor proposal for ${capability.target.schema}.${capability.target.table}. If it satisfies the reviewed automatic-approval policy, a separately trusted Runner worker may later apply it without a per-request human click. The model cannot approve, apply, start the worker, or change that policy.`
+        );
+      } else {
+        lines.push(
+          `Create an evidence-backed Synapsor proposal for ${capability.target.schema}.${capability.target.table}. After the required human approval, a separately trusted Runner worker may later apply it. The model cannot approve, apply, start the worker, or change that execution policy.`
+        );
+      }
+    } else {
+      lines.push(`Create an evidence-backed Synapsor proposal for ${capability.target.schema}.${capability.target.table}; the source database is not mutated by this tool.`);
+    }
   }
   if (capability.returns_hint) {
     lines.push(capability.returns_hint);