@synapsor/runner 1.4.121 → 1.4.122

package/dist/runner.mjs

@@ -22091,6 +22091,10 @@ var protocolVersions = {
   executionReceiptV3: "synapsor.execution-receipt.v3",
   executionReceiptV4: "synapsor.execution-receipt.v4",
   runnerRegistration: "synapsor.runner-registration.v1",
+  runnerControl: "synapsor.runner-control.v1",
+  runnerProposal: "synapsor.runner-proposal.v1",
+  runnerActivity: "synapsor.runner-activity.v1",
+  principalScope: "synapsor.principal-scope.v1",
   legacyWritebackJob: "1.0",
   normalizedWritebackJobV2: "2.0",
   normalizedWritebackJobV3: "3.0",
@@ -22116,6 +22120,28 @@ var columnValueSchema = z.object({
   column: safeIdentifier,
   value: scalar
 });
+var trustedScopeProviderSchema = z.enum(["environment", "http_claims", "cloud_session", "static_dev"]);
+function principalScopeFingerprint(input) {
+  return canonicalJsonDigest({
+    schema_version: protocolVersions.principalScope,
+    column: input.column,
+    binding: input.binding,
+    provider: input.provider,
+    value: input.value
+  });
+}
+var principalScopeGuardSchema = z.object({
+  schema_version: z.literal(protocolVersions.principalScope),
+  column: safeIdentifier,
+  binding: safeIdentifier,
+  provider: trustedScopeProviderSchema,
+  value_fingerprint: sha256,
+  value: scalar.optional()
+}).superRefine((scope, ctx) => {
+  if (scope.value !== void 0 && principalScopeFingerprint(scope) !== scope.value_fingerprint) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope fingerprint does not match its trusted value", path: ["value_fingerprint"] });
+  }
+});
 var resolvedDeduplicationComponentSchema = z.object({
   column: safeIdentifier,
   value: scalar,
@@ -22182,6 +22208,7 @@ var inverseDescriptorV1Schema = z.object({
     primary_key_column: safeIdentifier
   }),
   tenant_guard: columnValueSchema,
+  principal_scope: principalScopeGuardSchema.optional(),
   allowed_columns: z.array(safeIdentifier).max(256),
   members: z.array(inverseMemberSchema).min(1).max(100),
   max_rows: z.number().int().min(1).max(100),
@@ -22240,6 +22267,7 @@ var changeSetV1Schema = z.object({
   after: scalarMap,
   guards: z.object({
     tenant: columnValueSchema,
+    principal_scope: principalScopeGuardSchema.optional(),
     allowed_columns: z.array(z.string().min(1)).min(1),
     expected_version: columnValueSchema
   }),
@@ -22287,6 +22315,13 @@ var changeSetV1Schema = z.object({
       path: ["guards", "allowed_columns"]
     });
   }
+  if (changeSet.guards.principal_scope && allowed.has(changeSet.guards.principal_scope.column)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "principal scope column must not be patch-allowlisted",
+      path: ["guards", "allowed_columns"]
+    });
+  }
 });
 var changeSetV2Schema = z.object({
   schema_version: z.literal(protocolVersions.changeSetV2),
@@ -22317,6 +22352,7 @@ var changeSetV2Schema = z.object({
   after: boundedScalarRecord,
   guards: z.object({
     tenant: columnValueSchema,
+    principal_scope: principalScopeGuardSchema.optional(),
     allowed_columns: z.array(safeIdentifier).max(256),
     expected_version: columnValueSchema.optional(),
     version_advance: versionAdvanceSchema.optional(),
@@ -22347,6 +22383,7 @@ var changeSetV2Schema = z.object({
   }
   if (allowed.has(changeSet.source.primary_key.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "primary key column must not be patch-allowlisted", path: ["guards", "allowed_columns"] });
   if (allowed.has(changeSet.guards.tenant.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "tenant guard column must not be patch-allowlisted", path: ["guards", "allowed_columns"] });
+  if (changeSet.guards.principal_scope && allowed.has(changeSet.guards.principal_scope.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope column must not be patch-allowlisted", path: ["guards", "allowed_columns"] });
   if (changeSet.operation === "single_row_insert") {
     if (Object.keys(changeSet.before).length !== 0) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "INSERT before must be empty", path: ["before"] });
     if (!changeSet.guards.deduplication) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "INSERT requires source-enforced deduplication", path: ["guards", "deduplication"] });
@@ -22401,6 +22438,7 @@ var changeSetV3Schema = z.object({
   after: boundedScalarRecord,
   guards: z.object({
     tenant: columnValueSchema,
+    principal_scope: principalScopeGuardSchema.optional(),
     allowed_columns: z.array(safeIdentifier).max(256),
     expected_version: columnValueSchema.optional(),
     version_advance: versionAdvanceSchema.optional()
@@ -22422,6 +22460,7 @@ var changeSetV3Schema = z.object({
   if (changeSet.source.primary_key.value !== void 0 || changeSet.guards.expected_version) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "set guards live on frozen members, not the top-level envelope", path: ["frozen_set"] });
   const allowed = new Set(changeSet.guards.allowed_columns);
   for (const column of Object.keys(changeSet.patch)) if (!allowed.has(column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: `patch column not allowed: ${column}`, path: ["patch", column] });
+  if (changeSet.guards.principal_scope && allowed.has(changeSet.guards.principal_scope.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope column must not be patch-allowlisted", path: ["guards", "allowed_columns"] });
   for (const [index, member] of changeSet.frozen_set.members.entries()) {
     if (member.primary_key.column !== changeSet.source.primary_key.column) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "member primary key column must match source", path: ["frozen_set", "members", index, "primary_key", "column"] });
     if (changeSet.operation === "set_update") {
@@ -22461,7 +22500,7 @@ var compensationChangeSetV1Schema = z.object({
     descriptor: inverseDescriptorV1Schema,
     forward_receipt_hash: sha256
   }),
-  guards: z.object({ tenant: columnValueSchema, allowed_columns: z.array(safeIdentifier).max(256) }),
+  guards: z.object({ tenant: columnValueSchema, principal_scope: principalScopeGuardSchema.optional(), allowed_columns: z.array(safeIdentifier).max(256) }),
   evidence: z.object({ bundle_id: z.string().min(1), query_fingerprint: sha256, items: z.array(z.unknown()).max(100) }).passthrough(),
   approval: z.object({
     status: z.enum(["pending", "approved", "rejected", "canceled"]),
@@ -22478,6 +22517,7 @@ var compensationChangeSetV1Schema = z.object({
   if (descriptor.availability !== "available") ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation proposal requires an available inverse", path: ["compensation", "descriptor", "availability"] });
   if (descriptor.target.source_id !== changeSet.source.source_id || descriptor.target.schema !== changeSet.source.schema || descriptor.target.table !== changeSet.source.table || descriptor.target.primary_key_column !== changeSet.source.primary_key.column) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation descriptor target must match proposal source", path: ["compensation", "descriptor", "target"] });
   if (descriptor.tenant_guard.column !== changeSet.guards.tenant.column || descriptor.tenant_guard.value !== changeSet.guards.tenant.value || descriptor.tenant_guard.value !== changeSet.scope.tenant_id) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation tenant authority must match trusted proposal scope", path: ["guards", "tenant"] });
+  if (JSON.stringify(descriptor.principal_scope) !== JSON.stringify(changeSet.guards.principal_scope)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation principal authority must match inverse descriptor", path: ["guards", "principal_scope"] });
   if (JSON.stringify(descriptor.allowed_columns) !== JSON.stringify(changeSet.guards.allowed_columns)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation allowlist must match inverse descriptor", path: ["guards", "allowed_columns"] });
 });
 var publicConflictGuardSchema = z.discriminatedUnion("kind", [
@@ -22485,6 +22525,11 @@ var publicConflictGuardSchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("row_hash"), expected_hash: z.string().min(1) }),
   z.object({ kind: z.literal("none") })
 ]);
+var leasedContractRefSchema = z.object({
+  contract_id: z.string().min(1),
+  contract_version_id: z.string().min(1),
+  digest: sha256
+});
 var writebackJobV1Schema = z.object({
   schema_version: z.literal(protocolVersions.writebackJob),
   writeback_job_id: z.string().min(1),
@@ -22503,6 +22548,7 @@ var writebackJobV1Schema = z.object({
     primary_key: columnValueSchema
   }),
   tenant_guard: columnValueSchema,
+  principal_scope: principalScopeGuardSchema.optional(),
   allowed_columns: z.array(safeIdentifier).min(1),
   patch: scalarMap,
   conflict_guard: publicConflictGuardSchema,
@@ -22514,6 +22560,7 @@ var writebackJobV1Schema = z.object({
   })
 }).superRefine((job, ctx) => {
   validateAllowedPatchColumns(job.allowed_columns, Object.keys(job.patch), job.target.primary_key.column, job.tenant_guard.column, ctx);
+  if (job.principal_scope && job.allowed_columns.includes(job.principal_scope.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope column must not be patch-allowlisted", path: ["allowed_columns"] });
 });
 var normalizedWritebackJobV1Schema = writebackJobV1Schema.transform((job) => ({
   protocol_version: protocolVersions.legacyWritebackJob,
@@ -22527,7 +22574,8 @@ var normalizedWritebackJobV1Schema = writebackJobV1Schema.transform((job) => ({
     schema: job.target.schema,
     table: job.target.table,
     primary_key: job.target.primary_key,
-    tenant_guard: job.tenant_guard
+    tenant_guard: job.tenant_guard,
+    ...job.principal_scope ? { principal_scope: job.principal_scope } : {}
   },
   allowed_columns: job.allowed_columns,
   patch: job.patch,
@@ -22541,6 +22589,7 @@ var legacyWritebackJobSchema = z.object({
   job_id: z.string().min(1),
   proposal_id: z.string().min(1),
   approval_id: z.string().min(1),
+  contract: leasedContractRefSchema.optional(),
   source_id: z.string().min(1),
   engine: writebackEngineSchema,
   operation: z.literal("single_row_update").optional(),
@@ -22554,7 +22603,8 @@ var legacyWritebackJobSchema = z.object({
     tenant_guard: z.object({
       column: safeIdentifier,
       value: scalar
-    })
+    }),
+    principal_scope: principalScopeGuardSchema.optional()
   }),
   allowed_columns: z.array(safeIdentifier).min(1),
   patch: scalarMap,
@@ -22568,12 +22618,14 @@ var legacyWritebackJobSchema = z.object({
   attempt_count: z.number().int().nonnegative().optional()
 }).superRefine((job, ctx) => {
   validateAllowedPatchColumns(job.allowed_columns, Object.keys(job.patch), job.target.primary_key.column, job.target.tenant_guard.column, ctx);
+  if (job.target.principal_scope && job.allowed_columns.includes(job.target.principal_scope.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope column must not be patch-allowlisted", path: ["allowed_columns"] });
 });
 var normalizedWritebackJobV2InputSchema = z.object({
   protocol_version: z.literal(protocolVersions.normalizedWritebackJobV2),
   job_id: z.string().min(1),
   proposal_id: z.string().min(1),
   approval_id: sha256,
+  contract: leasedContractRefSchema.optional(),
   source_id: z.string().min(1),
   engine: writebackEngineSchema,
   operation: z.enum(["single_row_update", "single_row_insert", "single_row_delete"]),
@@ -22581,7 +22633,8 @@ var normalizedWritebackJobV2InputSchema = z.object({
     schema: safeIdentifier,
     table: safeIdentifier,
     primary_key: z.object({ column: safeIdentifier, value: scalar.optional() }),
-    tenant_guard: columnValueSchema
+    tenant_guard: columnValueSchema,
+    principal_scope: principalScopeGuardSchema.optional()
   }),
   allowed_columns: z.array(safeIdentifier).max(256),
   patch: boundedScalarRecord,
@@ -22602,6 +22655,7 @@ var normalizedWritebackJobV2InputSchema = z.object({
   }
   if (job.operation === "single_row_update" || job.operation === "single_row_insert") {
     validateAllowedPatchColumns(job.allowed_columns, Object.keys(job.patch), job.target.primary_key.column, job.target.tenant_guard.column, ctx);
+    if (job.target.principal_scope && job.allowed_columns.includes(job.target.principal_scope.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope column must not be patch-allowlisted", path: ["allowed_columns"] });
     if (Object.keys(job.patch).length === 0) ctx.addIssue({ code: z.ZodIssueCode.custom, message: `${job.operation} patch must not be empty`, path: ["patch"] });
   } else if (job.allowed_columns.length !== 0 || Object.keys(job.patch).length !== 0) {
     ctx.addIssue({ code: z.ZodIssueCode.custom, message: "DELETE must not allow or carry write columns", path: ["allowed_columns"] });
@@ -22658,6 +22712,7 @@ var writebackJobV2Schema = z.object({
     primary_key: z.object({ column: safeIdentifier, value: scalar.optional() })
   }),
   tenant_guard: columnValueSchema,
+  principal_scope: principalScopeGuardSchema.optional(),
   allowed_columns: z.array(safeIdentifier),
   mutation: writebackMutationV2Schema,
   idempotency_key: z.string().min(1),
@@ -22674,6 +22729,7 @@ var writebackJobV2Schema = z.object({
   }
   if (mutation.kind === "single_row_update" || mutation.kind === "single_row_insert") {
     validateAllowedPatchColumns(job.allowed_columns, Object.keys(mutation.values), job.target.primary_key.column, job.tenant_guard.column, ctx);
+    if (job.principal_scope && job.allowed_columns.includes(job.principal_scope.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope column must not be patch-allowlisted", path: ["allowed_columns"] });
   } else if (job.allowed_columns.length !== 0) {
     ctx.addIssue({ code: z.ZodIssueCode.custom, message: "DELETE must not allow write columns", path: ["allowed_columns"] });
   }
@@ -22697,7 +22753,8 @@ var writebackJobV2Schema = z.object({
     schema: job.target.schema,
     table: job.target.table,
     primary_key: job.target.primary_key,
-    tenant_guard: job.tenant_guard
+    tenant_guard: job.tenant_guard,
+    ...job.principal_scope ? { principal_scope: job.principal_scope } : {}
   },
   allowed_columns: job.allowed_columns,
   patch: job.mutation.kind === "single_row_delete" ? {} : job.mutation.values,
@@ -22714,10 +22771,11 @@ var normalizedWritebackJobV3InputSchema = z.object({
   job_id: z.string().min(1),
   proposal_id: z.string().min(1),
   approval_id: sha256,
+  contract: leasedContractRefSchema.optional(),
   source_id: z.string().min(1),
   engine: writebackEngineSchema,
   operation: setOperationSchema,
-  target: z.object({ schema: safeIdentifier, table: safeIdentifier, primary_key: z.object({ column: safeIdentifier, value: scalar.optional() }), tenant_guard: columnValueSchema }),
+  target: z.object({ schema: safeIdentifier, table: safeIdentifier, primary_key: z.object({ column: safeIdentifier, value: scalar.optional() }), tenant_guard: columnValueSchema, principal_scope: principalScopeGuardSchema.optional() }),
   allowed_columns: z.array(safeIdentifier).max(256),
   patch: boundedScalarRecord,
   conflict_guard: z.object({ kind: z.literal("none") }).default({ kind: "none" }),
@@ -22728,6 +22786,7 @@ var normalizedWritebackJobV3InputSchema = z.object({
   attempt_count: z.number().int().positive(),
   inverse_capture: inverseDescriptorV1Schema.optional()
 }).superRefine((job, ctx) => {
+  if (job.target.principal_scope && job.allowed_columns.includes(job.target.principal_scope.column)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "principal scope column must not be patch-allowlisted", path: ["allowed_columns"] });
   if (job.operation === "set_delete" && (job.allowed_columns.length || Object.keys(job.patch).length || job.version_advance)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "set DELETE cannot carry patch authority", path: ["patch"] });
   if (job.operation === "set_update" && (!Object.keys(job.patch).length || !job.version_advance)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "set UPDATE requires patch and version advance", path: ["patch"] });
   if (job.operation === "batch_insert" && !job.frozen_set.members.every((member) => member.deduplication)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "batch INSERT requires per-item source deduplication", path: ["frozen_set", "members"] });
@@ -22743,6 +22802,7 @@ var writebackJobV3Schema = z.object({
   operation: setOperationSchema,
   target: z.object({ schema: safeIdentifier, table: safeIdentifier, primary_key: z.object({ column: safeIdentifier, value: scalar.optional() }) }),
   tenant_guard: columnValueSchema,
+  principal_scope: principalScopeGuardSchema.optional(),
   allowed_columns: z.array(safeIdentifier).max(256),
   patch: boundedScalarRecord,
   version_advance: versionAdvanceSchema.optional(),
@@ -22758,7 +22818,7 @@ var writebackJobV3Schema = z.object({
   source_id: job.runner_scope.source_id,
   engine: job.engine,
   operation: job.operation,
-  target: { ...job.target, primary_key: { ...job.target.primary_key, value: void 0 }, tenant_guard: job.tenant_guard },
+  target: { ...job.target, primary_key: { ...job.target.primary_key, value: void 0 }, tenant_guard: job.tenant_guard, ...job.principal_scope ? { principal_scope: job.principal_scope } : {} },
   allowed_columns: job.allowed_columns,
   patch: job.patch,
   conflict_guard: { kind: "none" },
@@ -22780,6 +22840,7 @@ var writebackJobV4Schema = z.object({
   operation: reversalOperationSchema,
   target: z.object({ schema: safeIdentifier, table: safeIdentifier, primary_key: z.object({ column: safeIdentifier, value: scalar.optional() }) }),
   tenant_guard: columnValueSchema,
+  principal_scope: principalScopeGuardSchema.optional(),
   allowed_columns: z.array(safeIdentifier).max(256),
   patch: z.object({}).default({}),
   compensation: inverseDescriptorV1Schema,
@@ -22790,6 +22851,7 @@ var writebackJobV4Schema = z.object({
   if (job.compensation.availability !== "available") ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation job requires an available inverse", path: ["compensation", "availability"] });
   if (job.compensation.target.source_id !== job.runner_scope.source_id) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation source must match runner scope", path: ["compensation", "target", "source_id"] });
   if (job.operation !== job.compensation.operation || job.target.schema !== job.compensation.target.schema || job.target.table !== job.compensation.target.table || job.target.primary_key.column !== job.compensation.target.primary_key_column || job.tenant_guard.column !== job.compensation.tenant_guard.column || job.tenant_guard.value !== job.compensation.tenant_guard.value) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation public authority must match descriptor", path: ["compensation"] });
+  if (JSON.stringify(job.principal_scope) !== JSON.stringify(job.compensation.principal_scope)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation principal authority must match descriptor", path: ["compensation", "principal_scope"] });
 }).transform((job) => ({
   protocol_version: protocolVersions.normalizedWritebackJobV4,
   job_id: job.writeback_job_id,
@@ -22800,7 +22862,8 @@ var writebackJobV4Schema = z.object({
   operation: job.operation,
   target: {
     ...job.target,
-    tenant_guard: job.tenant_guard
+    tenant_guard: job.tenant_guard,
+    ...job.principal_scope ? { principal_scope: job.principal_scope } : {}
   },
   allowed_columns: job.allowed_columns,
   patch: job.patch,
@@ -22816,10 +22879,11 @@ var normalizedWritebackJobV4InputSchema = z.object({
   job_id: z.string().min(1),
   proposal_id: z.string().min(1),
   approval_id: sha256,
+  contract: leasedContractRefSchema.optional(),
   source_id: z.string().min(1),
   engine: writebackEngineSchema,
   operation: reversalOperationSchema,
-  target: z.object({ schema: safeIdentifier, table: safeIdentifier, primary_key: z.object({ column: safeIdentifier, value: scalar.optional() }), tenant_guard: columnValueSchema }),
+  target: z.object({ schema: safeIdentifier, table: safeIdentifier, primary_key: z.object({ column: safeIdentifier, value: scalar.optional() }), tenant_guard: columnValueSchema, principal_scope: principalScopeGuardSchema.optional() }),
   allowed_columns: z.array(safeIdentifier).max(256),
   patch: z.object({}).default({}),
   conflict_guard: z.object({ kind: z.literal("none") }).default({ kind: "none" }),
@@ -22832,6 +22896,7 @@ var normalizedWritebackJobV4InputSchema = z.object({
   if (job.operation !== job.compensation.operation) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation operation mismatch", path: ["operation"] });
   if (job.source_id !== job.compensation.target.source_id || job.target.schema !== job.compensation.target.schema || job.target.table !== job.compensation.target.table || job.target.primary_key.column !== job.compensation.target.primary_key_column) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation target mismatch", path: ["target"] });
   if (job.target.tenant_guard.column !== job.compensation.tenant_guard.column || job.target.tenant_guard.value !== job.compensation.tenant_guard.value) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation tenant mismatch", path: ["target", "tenant_guard"] });
+  if (JSON.stringify(job.target.principal_scope) !== JSON.stringify(job.compensation.principal_scope)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: "compensation principal mismatch", path: ["target", "principal_scope"] });
 });
 var writebackJobSchema = z.union([legacyWritebackJobSchema, normalizedWritebackJobV4InputSchema, normalizedWritebackJobV3InputSchema, normalizedWritebackJobV2InputSchema, normalizedWritebackJobV1Schema, writebackJobV4Schema, writebackJobV3Schema, writebackJobV2Schema]);
 var executionReceiptV1Schema = z.object({
@@ -23050,6 +23115,7 @@ var normalizedWritebackResultV4Schema = z.object({
 var writebackResultSchema = z.union([legacyWritebackResultSchema, normalizedExecutionReceiptV1Schema, normalizedWritebackResultV4Schema, normalizedWritebackResultV3Schema, normalizedWritebackResultV2Schema]);
 var runnerRegistrationV1Schema = z.object({
   schema_version: z.literal(protocolVersions.runnerRegistration),
+  protocol_version: z.literal(protocolVersions.runnerControl).optional(),
   runner_id: z.string().min(1),
   runner_version: z.string().min(1),
   engines: z.array(writebackEngineSchema).min(1),
@@ -23058,8 +23124,59 @@ var runnerRegistrationV1Schema = z.object({
     project_id: z.string().min(1),
     source_ids: z.array(z.string().min(1)).min(1)
   }),
+  contracts: z.array(z.object({
+    contract_id: z.string().min(1),
+    contract_version_id: z.string().min(1),
+    digest: sha256
+  })).max(100).optional(),
   registered_at: z.string().min(1)
 });
+var runnerProposalV1Schema = z.object({
+  schema_version: z.literal(protocolVersions.runnerProposal),
+  runner_id: z.string().min(1),
+  source_id: z.string().min(1),
+  mapping_id: z.string().min(1).optional(),
+  contract: z.object({
+    contract_id: z.string().min(1),
+    contract_version_id: z.string().min(1),
+    digest: sha256
+  }),
+  change_set: z.union([changeSetV1Schema, changeSetV2Schema, changeSetV3Schema, compensationChangeSetV1Schema]),
+  evidence_metadata: z.record(z.unknown()).optional(),
+  query_audit: z.record(z.unknown()).optional()
+}).superRefine((proposal, ctx) => {
+  if (proposal.change_set.source_database_mutated) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Runner proposals must describe an unchanged source database", path: ["change_set", "source_database_mutated"] });
+  }
+  if (proposal.change_set.guards.principal_scope?.value !== void 0) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Runner Cloud proposals must use fingerprint-only principal scope metadata", path: ["change_set", "guards", "principal_scope", "value"] });
+  }
+});
+var runnerActivityV1Schema = z.object({
+  schema_version: z.literal(protocolVersions.runnerActivity),
+  event_id: z.string().min(1).max(120).regex(/^[A-Za-z0-9_.:-]+$/),
+  event_type: z.enum(["evidence.recorded", "query_audit.recorded", "replay.recorded", "worker.diagnostic"]),
+  runner_id: z.string().min(1).max(120),
+  source_id: z.string().min(1).max(120),
+  proposal_id: z.string().min(1).max(120).optional(),
+  job_id: z.string().min(1).max(120).optional(),
+  contract_id: z.string().min(1).max(120).optional(),
+  contract_version_id: z.string().min(1).max(120).optional(),
+  contract_digest: sha256.optional(),
+  capability: z.string().min(1).max(160).optional(),
+  workflow: z.string().min(1).max(160).optional(),
+  tenant_id: z.string().min(1).max(160).optional(),
+  principal: z.string().min(1).max(200).optional(),
+  business_object: z.string().min(1).max(160).optional(),
+  object_id: z.string().min(1).max(200).optional(),
+  status: z.string().min(1).max(80).optional(),
+  evidence_ids: z.array(z.string().min(1).max(160)).max(100).optional(),
+  query_audit_ids: z.array(z.string().min(1).max(160)).max(100).optional(),
+  receipt_id: z.string().min(1).max(160).optional(),
+  replay_id: z.string().min(1).max(160).optional(),
+  detail: z.record(z.unknown()).optional(),
+  occurred_at: z.string().min(1).max(80).optional()
+}).strict();
 function validateAllowedPatchColumns(allowedColumns, patchColumns, primaryKeyColumn, tenantGuardColumn, ctx) {
   const allow = new Set(allowedColumns);
   for (const column of patchColumns) {
@@ -23132,26 +23249,189 @@ function parseWritebackResult(input) {
 function parseRunnerRegistration(input) {
   return runnerRegistrationV1Schema.parse(input);
 }
+function parseRunnerProposal(input) {
+  return runnerProposalV1Schema.parse(input);
+}
+function parseRunnerActivity(input) {
+  return runnerActivityV1Schema.parse(input);
+}
 
 // packages/control-plane-client/src/index.ts
+var CloudControlError = class extends Error {
+  error_code;
+  retryable;
+  retry_after_ms;
+  request_id;
+  status;
+  details;
+  constructor(shape) {
+    super(shape.message);
+    this.name = "CloudControlError";
+    this.error_code = shape.error_code;
+    this.retryable = shape.retryable;
+    this.retry_after_ms = shape.retry_after_ms;
+    this.request_id = shape.request_id;
+    this.status = shape.status;
+    this.details = shape.details;
+  }
+  toJSON() {
+    return {
+      error_code: this.error_code,
+      message: this.message,
+      retryable: this.retryable,
+      ...this.retry_after_ms === void 0 ? {} : { retry_after_ms: this.retry_after_ms },
+      ...this.request_id ? { request_id: this.request_id } : {},
+      status: this.status,
+      ...this.details ? { details: this.details } : {}
+    };
+  }
+};
+var CloudControlClient = class {
+  baseUrl;
+  credential;
+  credentialKind;
+  userAgent;
+  maxRetries;
+  timeoutMs;
+  constructor(config) {
+    this.baseUrl = normalizeBaseUrl(config.baseUrl);
+    this.credential = requireValue(config.credential, "Cloud credential");
+    this.credentialKind = config.credentialKind ?? "service";
+    this.userAgent = config.userAgent ?? "synapsor-cloud-client";
+    this.maxRetries = Math.max(0, Math.min(5, config.maxRetries ?? 2));
+    this.timeoutMs = Math.max(1e3, Math.min(12e4, config.timeoutMs ?? 15e3));
+  }
+  async get(path9) {
+    return this.request(path9, { method: "GET" });
+  }
+  async post(path9, body, options = {}) {
+    return this.request(path9, { ...options, method: "POST", body });
+  }
+  async request(path9, options = {}) {
+    const method = options.method ?? "GET";
+    const retryPermitted = options.retry !== false && (method === "GET" || Boolean(options.idempotencyKey));
+    let attempt = 0;
+    while (true) {
+      try {
+        return await this.requestOnce(path9, options);
+      } catch (error) {
+        const retryable = error instanceof CloudControlError && error.retryable;
+        if (!retryPermitted || !retryable || attempt >= this.maxRetries) throw error;
+        const delay = error.retry_after_ms ?? Math.min(5e3, 200 * 2 ** attempt);
+        attempt += 1;
+        await sleep(delay);
+      }
+    }
+  }
+  async pushContract(input) {
+    const localDigest = canonicalJsonDigest(input.contract);
+    const payload = {
+      schema_version: "synapsor.cloud-contract-push.v0.1",
+      contract: input.contract,
+      name: input.name,
+      description: input.description,
+      source: input.source,
+      source_versions: input.sourceVersions ?? {},
+      activate: input.activate === true,
+      idempotency_key: input.idempotencyKey,
+      local_digest: localDigest
+    };
+    const response = await this.post(
+      `/v1/control/projects/${encodeURIComponent(input.projectId)}/agent-contracts`,
+      payload,
+      { idempotencyKey: input.idempotencyKey ?? localDigest }
+    );
+    const remoteDigest = firstString(response.digest, normalizeRecord(response.version)?.digest);
+    if (!remoteDigest) {
+      throw new CloudControlError({
+        error_code: "contract_digest_missing",
+        message: "Cloud did not return the canonical contract digest.",
+        retryable: false,
+        status: 502
+      });
+    }
+    if (remoteDigest !== localDigest) {
+      throw new CloudControlError({
+        error_code: "contract_digest_mismatch",
+        message: `Cloud contract digest ${remoteDigest} does not match local digest ${localDigest}.`,
+        retryable: false,
+        status: 409,
+        details: { local_digest: localDigest, remote_digest: remoteDigest }
+      });
+    }
+    return { ...response, local_digest: localDigest };
+  }
+  async requestOnce(path9, options) {
+    const endpoint = new URL(path9, `${this.baseUrl}/`);
+    if (endpoint.origin !== new URL(this.baseUrl).origin) {
+      throw new CloudControlError({ error_code: "invalid_api_path", message: "Cloud API path must remain on the configured origin.", retryable: false, status: 0 });
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let response;
+    try {
+      response = await fetch(endpoint.toString(), {
+        method: options.method ?? "GET",
+        headers: {
+          accept: "application/json",
+          authorization: `Bearer ${this.credential}`,
+          "user-agent": this.userAgent,
+          "x-synapsor-credential-kind": this.credentialKind,
+          ...options.body === void 0 ? {} : { "content-type": "application/json" },
+          ...options.idempotencyKey ? { "idempotency-key": options.idempotencyKey } : {},
+          ...options.headers
+        },
+        ...options.body === void 0 ? {} : { body: JSON.stringify(options.body) },
+        signal: controller.signal
+      });
+    } catch (error) {
+      const timeout = error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+      throw new CloudControlError({
+        error_code: timeout ? "request_timeout" : "network_unavailable",
+        message: timeout ? "Cloud request timed out." : "Cloud request could not reach the configured API.",
+        retryable: true,
+        retry_after_ms: 500,
+        status: 0
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload.ok === false) throw cloudControlError(response, payload);
+    return payload;
+  }
+};
 var ControlPlaneClient = class {
   baseUrl;
   runnerToken;
   sourceId;
+  runnerId;
+  transport;
   constructor(config) {
     this.baseUrl = config.baseUrl.replace(/\/+$/, "");
     this.runnerToken = config.runnerToken;
     this.sourceId = config.sourceId;
+    this.runnerId = config.runnerId;
+    this.transport = new CloudControlClient({
+      baseUrl: config.baseUrl,
+      credential: config.runnerToken,
+      credentialKind: "runner",
+      userAgent: "synapsor-runner-control-plane-client"
+    });
   }
   async claim(options = {}) {
     const body = {
       source_id: options.sourceId || this.sourceId,
+      runner_id: options.runnerId || this.runnerId,
       limit: options.limit ?? 1,
       lease_seconds: options.leaseSeconds
     };
     const response = await this.post("/v1/writeback/jobs/claim", body);
     const jobs = Array.isArray(response.jobs) ? response.jobs : [];
-    return jobs.map((job) => parseWritebackJob(job));
+    return jobs.map((job) => {
+      const parsed = parseWritebackJob(job);
+      return Object.assign(parsed, { cloud_lease: cloudLease(job) });
+    });
   }
   async register(payload) {
     const registration = parseRunnerRegistration(payload);
@@ -23160,18 +23440,36 @@ var ControlPlaneClient = class {
   async runnerHeartbeat(payload) {
     return this.post("/v1/runner/heartbeat", payload);
   }
-  async heartbeat(jobId, leaseSeconds = 60) {
-    await this.post(`/v1/writeback/jobs/${encodeURIComponent(jobId)}/heartbeat`, { lease_seconds: leaseSeconds });
+  async submitProposal(payload) {
+    return this.post("/v1/runner/proposals", parseRunnerProposal(payload));
+  }
+  async submitActivity(payload) {
+    return this.post("/v1/runner/activity", parseRunnerActivity(payload));
+  }
+  async proposalStatus(proposalId) {
+    return this.transport.get(`/v1/runner/proposals/${encodeURIComponent(requireValue(proposalId, "proposal_id"))}`);
   }
-  async renewLease(jobId, leaseSeconds = 60) {
-    return this.post(`/v1/writeback/jobs/${encodeURIComponent(jobId)}/heartbeat`, { lease_seconds: leaseSeconds });
+  async heartbeat(jobId, leaseId, runnerId = this.runnerId, leaseSeconds = 60) {
+    await this.renewLease(jobId, leaseId, runnerId, leaseSeconds);
   }
-  async result(result) {
+  async renewLease(jobId, leaseId, runnerId = this.runnerId, leaseSeconds = 60) {
+    return this.post(`/v1/writeback/jobs/${encodeURIComponent(jobId)}/heartbeat`, {
+      runner_id: requireValue(runnerId, "runner_id"),
+      lease_id: requireValue(leaseId, "lease_id"),
+      lease_seconds: leaseSeconds
+    });
+  }
+  async result(result, leaseId) {
     const parsed = parseWritebackResult(result);
-    await this.post(`/v1/writeback/jobs/${encodeURIComponent(parsed.job_id)}/result`, parsed);
+    const cloudSafeResult = { ...parsed };
+    delete cloudSafeResult.inverse;
+    return this.post(`/v1/writeback/jobs/${encodeURIComponent(parsed.job_id)}/result`, {
+      ...cloudSafeResult,
+      lease_id: requireValue(leaseId, "lease_id")
+    });
   }
-  async submitReceipt(result) {
-    await this.result(result);
+  async submitReceipt(result, leaseId) {
+    return this.result(result, leaseId);
   }
   async adapterTools(adapterId, options = {}) {
     const response = await this.post("/v1/agent/adapters/tools", {
@@ -23220,38 +23518,26 @@ var ControlPlaneClient = class {
     return { ok: health.ok, status: health.status, authenticated: false, details: { fallback: "health_endpoint_only" } };
   }
   async post(path9, body) {
-    const response = await this.fetchWithRetry(path9, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.runnerToken}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok || !payload?.ok) {
-      const code = typeof payload?.error === "string" ? payload.error : `http_${response.status}`;
-      throw new Error(`control plane request failed: ${code}`);
-    }
-    return payload;
-  }
-  async fetchWithRetry(path9, init2) {
-    let lastError;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-      try {
-        const response = await fetch(`${this.baseUrl}${path9}`, init2);
-        if (![408, 429, 500, 502, 503, 504].includes(response.status)) return response;
-        if (attempt === 2) return response;
-        lastError = new Error(`retryable_http_${response.status}`);
-      } catch (error) {
-        lastError = error;
-        if (attempt === 2) throw error;
-      }
-      await sleep(100 * 2 ** attempt + Math.floor(Math.random() * 25));
-    }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    const normalizedBody = JSON.parse(JSON.stringify(body));
+    return this.transport.post(path9, normalizedBody, { idempotencyKey: canonicalJsonDigest({ path: path9, body: normalizedBody }) });
   }
 };
+function cloudLease(input) {
+  const record = normalizeRecord(input);
+  const publicLease = normalizeRecord(record?.lease);
+  const leaseId = typeof publicLease?.lease_id === "string" ? publicLease.lease_id : typeof record?.lease_id === "string" ? record.lease_id : "";
+  const expiresAt = publicLease?.expires_at ?? record?.lease_expires_at;
+  const attempt = Number(publicLease?.attempt ?? record?.attempt_count ?? 0);
+  if (!leaseId || typeof expiresAt !== "string" && typeof expiresAt !== "number" || !Number.isSafeInteger(attempt) || attempt < 1) {
+    throw new Error("control plane returned a writeback job without a valid lease");
+  }
+  return { leaseId, expiresAt, attempt };
+}
+function requireValue(value, field) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) throw new Error(`${field} is required for Cloud lease ownership`);
+  return normalized;
+}
 function normalizeTool(value) {
   const record = normalizeRecord(value);
   if (!record || typeof record.name !== "string" || record.name.length === 0) return void 0;
@@ -23268,12 +23554,59 @@ function normalizeTool(value) {
 function normalizeRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
+function normalizeBaseUrl(value) {
+  const normalized = String(value || "").trim().replace(/\/+$/, "");
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new CloudControlError({ error_code: "invalid_api_url", message: "Cloud API URL is invalid.", retryable: false, status: 0 });
+  }
+  if (!/^https?:$/.test(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) {
+    throw new CloudControlError({ error_code: "invalid_api_url", message: "Cloud API URL must be an HTTP(S) origin without credentials, query, or fragment.", retryable: false, status: 0 });
+  }
+  return normalized;
+}
+function firstString(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0) ?? "";
+}
+function cloudControlError(response, payload) {
+  const errorCode = firstString(payload.error_code, payload.error, `http_${response.status}`);
+  const requestId = firstString(payload.request_id, response.headers.get("x-request-id"));
+  const retryAfterHeader = response.headers.get("retry-after");
+  const payloadDelay = Number(payload.retry_after_ms);
+  const headerSeconds = retryAfterHeader === null ? Number.NaN : Number(retryAfterHeader);
+  const retryAfterMs = Number.isFinite(payloadDelay) && payloadDelay >= 0 ? payloadDelay : Number.isFinite(headerSeconds) && headerSeconds >= 0 ? Math.round(headerSeconds * 1e3) : void 0;
+  const retryable = payload.retryable === true || [408, 425, 429, 502, 503, 504].includes(response.status);
+  const message2 = firstString(payload.message, payload.error_description, humanCloudErrorMessage(errorCode, response.status));
+  const details = normalizeRecord(payload.details) ?? (Array.isArray(payload.errors) ? { errors: payload.errors } : void 0);
+  return new CloudControlError({
+    error_code: errorCode,
+    message: message2,
+    retryable,
+    ...retryAfterMs === void 0 ? {} : { retry_after_ms: retryAfterMs },
+    ...requestId ? { request_id: requestId } : {},
+    status: response.status,
+    ...details ? { details } : {}
+  });
+}
+function humanCloudErrorMessage(code, status) {
+  if (code === "payment_required") return "This project does not currently have the required Cloud entitlement.";
+  if (code === "feature_not_entitled") return "This Cloud feature is not enabled for the selected project.";
+  if (status === 401) return "Cloud authentication failed or the credential expired.";
+  if (status === 403) return "The authenticated principal is not authorized for this operation.";
+  if (status === 404) return "The requested Cloud resource was not found in the selected scope.";
+  if (status === 409) return "Cloud rejected the request because the current state conflicts with it.";
+  if (status === 429) return "Cloud rate-limited the request; retry after the supplied delay.";
+  if (status >= 500) return "Cloud is temporarily unable to complete the request.";
+  return `Cloud request failed (${code}).`;
+}
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
 // packages/config/src/index.ts
-var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["version", "mode", "storage", "sources", "trusted_context", "contexts", "executors", "capabilities", "contracts", "policies", "approvals", "operator_identity", "session_auth", "rate_limits", "metrics", "graduated_trust", "cloud", "strict", "result_format"]);
+var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["version", "mode", "storage", "sources", "trusted_context", "contexts", "executors", "capabilities", "contracts", "policies", "approvals", "operator_identity", "session_auth", "rate_limits", "metrics", "graduated_trust", "cloud", "governance", "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"]);
@@ -23338,6 +23671,7 @@ var SESSION_AUTH_KEYS = /* @__PURE__ */ new Set([
 var RATE_LIMITS_KEYS = /* @__PURE__ */ new Set(["enabled", "default", "capabilities"]);
 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 SOURCE_KEYS = /* @__PURE__ */ new Set([
   "engine",
   "read_url_env",
@@ -23350,7 +23684,7 @@ var SOURCE_KEYS = /* @__PURE__ */ new Set([
 ]);
 var SOURCE_POOL_KEYS = /* @__PURE__ */ new Set(["max_connections", "connection_timeout_ms", "idle_timeout_ms", "queue_timeout_ms", "queue_limit"]);
 var SOURCE_RECEIPT_KEYS = /* @__PURE__ */ new Set(["authority", "provisioning", "schema", "table"]);
-var TRUSTED_CONTEXT_KEYS = /* @__PURE__ */ new Set(["provider", "values"]);
+var TRUSTED_CONTEXT_KEYS = /* @__PURE__ */ new Set(["provider", "values", "tenant_binding", "principal_binding"]);
 var CONTEXT_KEYS = TRUSTED_CONTEXT_KEYS;
 var EXECUTOR_KEYS = /* @__PURE__ */ new Set(["type", "url_env", "method", "auth", "signing_secret_env", "timeout_ms", "command_env"]);
 var EXECUTOR_AUTH_KEYS = /* @__PURE__ */ new Set(["type", "token_env"]);
@@ -23382,7 +23716,7 @@ var CAPABILITY_KEYS = /* @__PURE__ */ new Set([
   "contract_provenance"
 ]);
 var CONTRACT_PROVENANCE_KEYS = /* @__PURE__ */ new Set(["digest", "version"]);
-var TARGET_KEYS = /* @__PURE__ */ new Set(["schema", "table", "primary_key", "tenant_key", "single_tenant_dev"]);
+var TARGET_KEYS = /* @__PURE__ */ new Set(["schema", "table", "primary_key", "tenant_key", "principal_scope_key", "single_tenant_dev"]);
 var LOOKUP_KEYS = /* @__PURE__ */ new Set(["id_from_arg"]);
 var ARG_KEYS = /* @__PURE__ */ new Set(["type", "description", "required", "max_length", "minimum", "maximum", "enum", "max_items", "fields"]);
 var PATCH_BINDING_KEYS = /* @__PURE__ */ new Set(["fixed", "from_arg", "from_item"]);
@@ -23478,6 +23812,7 @@ function validateRunnerCapabilityConfig(input) {
   validateApprovals(input.approvals, strict, errors);
   const hasContracts = validateContracts(input.contracts, errors);
   validateCloud(input.cloud, input.mode, strict, errors);
+  validateGovernance(input.governance, strict, errors);
   validateSources(input.sources, input.mode, strict, errors, warnings);
   validateReceiptTopology(input.sources, input.storage, errors);
   validateContexts(input.contexts, strict, errors, warnings);
@@ -23496,6 +23831,34 @@ function validateRunnerCapabilityConfig(input) {
   scanForForbiddenFields(input, "$", errors);
   return { ok: errors.length === 0, errors, warnings };
 }
+function validateGovernance(value, strict, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push({ path: "$.governance", code: "GOVERNANCE_NOT_OBJECT", message: "governance must be an object." });
+    return;
+  }
+  if (strict) checkUnknownKeys(value, GOVERNANCE_KEYS, "$.governance", errors);
+  if (value.mode !== "local_only" && value.mode !== "cloud_linked") {
+    errors.push({ path: "$.governance.mode", code: "INVALID_GOVERNANCE_MODE", message: "governance.mode must be local_only or cloud_linked." });
+  }
+  if (value.mode === "cloud_linked" && !isNonEmptyString(value.connection_file)) {
+    errors.push({ path: "$.governance.connection_file", code: "CLOUD_LINKED_CONNECTION_REQUIRED", message: "cloud_linked governance requires a reviewed Cloud connection file." });
+  }
+  if (value.connection_file !== void 0 && !isNonEmptyString(value.connection_file)) {
+    errors.push({ path: "$.governance.connection_file", code: "INVALID_GOVERNANCE_CONNECTION_FILE", message: "governance.connection_file must be a non-empty path." });
+  }
+  if (value.evidence_residency !== void 0 && value.evidence_residency !== "metadata_only") {
+    errors.push({ path: "$.governance.evidence_residency", code: "UNSUPPORTED_EVIDENCE_RESIDENCY", message: "Only metadata_only Cloud evidence residency is supported; full evidence remains local." });
+  }
+  if (value.queue_when_unavailable !== void 0 && typeof value.queue_when_unavailable !== "boolean") {
+    errors.push({ path: "$.governance.queue_when_unavailable", code: "INVALID_GOVERNANCE_QUEUE_POLICY", message: "queue_when_unavailable must be true or false." });
+  }
+  for (const [key, min, max] of [["sync_interval_ms", 250, 3e5], ["max_attempts", 1, 100], ["outbox_retention_days", 1, 3650]]) {
+    if (value[key] !== void 0 && (!Number.isSafeInteger(value[key]) || Number(value[key]) < min || Number(value[key]) > max)) {
+      errors.push({ path: `$.governance.${key}`, code: "INVALID_GOVERNANCE_LIMIT", message: `${key} must be an integer from ${min} through ${max}.` });
+    }
+  }
+}
 function validateMetrics(value, strict, errors) {
   if (value === void 0) return;
   if (!isRecord(value)) {
@@ -24472,6 +24835,7 @@ function validateTarget(value, path9, strict, errors, warnings) {
     }
   }
   const hasTenantKey = isSafeIdentifier(value.tenant_key);
+  const hasPrincipalScopeKey = isSafeIdentifier(value.principal_scope_key);
   const singleTenant = value.single_tenant_dev === true;
   if (!hasTenantKey && !singleTenant) {
     errors.push({
@@ -24480,6 +24844,12 @@ function validateTarget(value, path9, strict, errors, warnings) {
       message: "tenant_key is required unless target.single_tenant_dev is explicitly true for a local dev example."
     });
   }
+  if (value.principal_scope_key !== void 0 && !hasPrincipalScopeKey) {
+    errors.push({ path: `${path9}.principal_scope_key`, code: "INVALID_PRINCIPAL_SCOPE_KEY", message: "principal_scope_key must be a fixed safe identifier." });
+  }
+  if (hasPrincipalScopeKey && !hasTenantKey) {
+    errors.push({ path: `${path9}.principal_scope_key`, code: "PRINCIPAL_SCOPE_TENANT_REQUIRED", message: "principal_scope_key can only narrow a target that also declares tenant_key." });
+  }
   if (singleTenant) {
     warnings.push({
       path: `${path9}.single_tenant_dev`,
@@ -25334,6 +25704,7 @@ function assertCompensationJobIntegrity(job) {
   if (descriptor.operation !== job.operation) throw new Error("COMPENSATION_OPERATION_MISMATCH");
   if (descriptor.target.source_id !== job.source_id || descriptor.target.schema !== job.target.schema || descriptor.target.table !== job.target.table || descriptor.target.primary_key_column !== job.target.primary_key.column) throw new Error("COMPENSATION_TARGET_MISMATCH");
   if (descriptor.tenant_guard.column !== job.target.tenant_guard.column || descriptor.tenant_guard.value !== job.target.tenant_guard.value) throw new Error("COMPENSATION_TENANT_MISMATCH");
+  if (JSON.stringify(descriptor.principal_scope) !== JSON.stringify(job.target.principal_scope)) throw new Error("COMPENSATION_PRINCIPAL_SCOPE_MISMATCH");
   if (descriptor.members.length < 1 || descriptor.members.length > descriptor.max_rows || descriptor.max_rows > 100) throw new Error("COMPENSATION_ROW_CAP_EXCEEDED");
   const identities = descriptor.members.map((member) => JSON.stringify(member.primary_key.value));
   if (new Set(identities).size !== identities.length) throw new Error("COMPENSATION_IDENTITY_NOT_UNIQUE");
@@ -25474,6 +25845,7 @@ function assertFrozenSetJobIntegrity(job) {
       if (!job.version_advance || job.version_advance.strategy !== "integer_increment" || !member.expected_version || member.expected_version.column !== job.version_advance.column) throw new Error("SET_VERSION_GUARD_REQUIRED");
       if (typeof member.expected_version.value !== "number" || member.before[job.version_advance.column] !== member.expected_version.value) throw new Error("SET_VERSION_GUARD_MISMATCH");
       if (member.before[job.target.tenant_guard.column] !== job.target.tenant_guard.value) throw new Error("SET_TENANT_GUARD_MISMATCH");
+      if (job.target.principal_scope && member.before[job.target.principal_scope.column] !== job.target.principal_scope.value) throw new Error("SET_PRINCIPAL_SCOPE_MISMATCH");
       const expectedAfter = { ...member.before, ...job.patch, [job.version_advance.column]: member.expected_version.value + 1 };
       if (!recordsEqual(member.after, expectedAfter)) throw new Error("SET_AFTER_STATE_MISMATCH");
       if (!reviewedDigestMatches(member.before_digest, { primary_key: member.primary_key.value, before: member.before })) throw new Error("SET_BEFORE_DIGEST_MISMATCH");
@@ -25481,6 +25853,7 @@ function assertFrozenSetJobIntegrity(job) {
     } else if (job.operation === "set_delete") {
       if (!member.expected_version || member.before[member.expected_version.column] !== member.expected_version.value) throw new Error("SET_VERSION_GUARD_MISMATCH");
       if (member.before[job.target.tenant_guard.column] !== job.target.tenant_guard.value) throw new Error("SET_TENANT_GUARD_MISMATCH");
+      if (job.target.principal_scope && member.before[job.target.principal_scope.column] !== job.target.principal_scope.value) throw new Error("SET_PRINCIPAL_SCOPE_MISMATCH");
       if (Object.keys(member.after).length !== 0) throw new Error("SET_DELETE_PATCH_FORBIDDEN");
       if (!reviewedDigestMatches(member.before_digest, { primary_key: member.primary_key.value, before: member.before })) throw new Error("SET_BEFORE_DIGEST_MISMATCH");
       if (!reviewedDigestMatches(member.tombstone_digest, { primary_key: member.primary_key.value, expected_version: member.expected_version })) throw new Error("SET_TOMBSTONE_DIGEST_MISMATCH");
@@ -25490,6 +25863,7 @@ function assertFrozenSetJobIntegrity(job) {
       const tenant = components.find((component) => component.column === job.target.tenant_guard.column);
       if (!primary || primary.value !== member.primary_key.value || !tenant || tenant.source !== "trusted_tenant" || tenant.value !== job.target.tenant_guard.value) throw new Error("BATCH_DEDUP_REQUIRED");
       if (member.after[job.target.primary_key.column] !== member.primary_key.value || member.after[job.target.tenant_guard.column] !== job.target.tenant_guard.value) throw new Error("BATCH_IDENTITY_MISMATCH");
+      if (job.target.principal_scope && member.after[job.target.principal_scope.column] !== job.target.principal_scope.value) throw new Error("BATCH_PRINCIPAL_SCOPE_MISMATCH");
       if (!reviewedDigestMatches(member.after_digest, { primary_key: member.primary_key.value, after: member.after })) throw new Error("SET_AFTER_DIGEST_MISMATCH");
     }
   }
@@ -25548,7 +25922,7 @@ function loadConfig(env = process.env) {
     runnerToken: requireEnv(env, "SYNAPSOR_RUNNER_TOKEN"),
     runnerId: env.SYNAPSOR_RUNNER_ID || "synapsor-runner-local",
     sourceId: requireEnv(env, "SYNAPSOR_SOURCE_ID"),
-    databaseUrl: env.SYNAPSOR_DATABASE_URL || "",
+    databaseUrl: env.SYNAPSOR_DATABASE_WRITE_URL || env.SYNAPSOR_DATABASE_URL || "",
     engine,
     pollIntervalMs: Number(env.SYNAPSOR_POLL_INTERVAL_MS || "5000"),
     statementTimeoutMs: optionalPositiveInteger(env.SYNAPSOR_WRITEBACK_TIMEOUT_MS, "SYNAPSOR_WRITEBACK_TIMEOUT_MS"),
@@ -25592,7 +25966,7 @@ function createLogger(config = { logLevel: "info" }) {
   }
 }
 async function doctorChecks(config, adapter) {
-  const client = new ControlPlaneClient({ baseUrl: config.controlPlaneUrl, runnerToken: config.runnerToken, sourceId: config.sourceId });
+  const client = new ControlPlaneClient({ baseUrl: config.controlPlaneUrl, runnerToken: config.runnerToken, sourceId: config.sourceId, runnerId: config.runnerId });
   const [controlPlane, database] = await Promise.all([
     client.doctor(),
     adapter.doctor(config)
@@ -25608,38 +25982,86 @@ async function doctorChecks(config, adapter) {
     database
   };
 }
-async function runOnce(config, adapters2) {
+function failedWritebackResult(job, runnerId, errorCode) {
+  const common = {
+    protocol_version: job.protocol_version,
+    job_id: job.job_id,
+    runner_id: runnerId,
+    status: "failed",
+    affected_rows: 0,
+    completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    error_code: errorCode
+  };
+  let result;
+  if (job.protocol_version === protocolVersions.legacyWritebackJob) {
+    result = common;
+  } else if (job.protocol_version === protocolVersions.normalizedWritebackJobV2) {
+    const primaryKey = job.target.primary_key;
+    result = {
+      ...common,
+      operation: job.operation,
+      receipt_authority: "runner_ledger",
+      target_identity: [{ column: primaryKey.column, value: primaryKey.value ?? job.patch[primaryKey.column] ?? null }]
+    };
+  } else if (job.protocol_version === protocolVersions.normalizedWritebackJobV3) {
+    result = {
+      ...common,
+      operation: job.operation,
+      receipt_authority: "runner_ledger",
+      target_identities: job.frozen_set.members.map((member) => member.primary_key),
+      set_digest: job.frozen_set.set_digest,
+      member_effects: []
+    };
+  } else {
+    result = {
+      ...common,
+      operation: job.operation,
+      receipt_authority: "runner_ledger",
+      target_identities: job.compensation.members.map((member) => member.primary_key),
+      member_effects: []
+    };
+  }
+  return { ...result, result_hash: canonicalJsonDigest(result) };
+}
+async function runOnce(config, adapters2, verifyAuthority, reportResult) {
   const logger = createLogger(config);
-  const client = new ControlPlaneClient({ baseUrl: config.controlPlaneUrl, runnerToken: config.runnerToken, sourceId: config.sourceId });
-  const jobs = await client.claim({ sourceId: config.sourceId, limit: 1 });
+  const client = new ControlPlaneClient({ baseUrl: config.controlPlaneUrl, runnerToken: config.runnerToken, sourceId: config.sourceId, runnerId: config.runnerId });
+  const jobs = await client.claim({ sourceId: config.sourceId, runnerId: config.runnerId, limit: 1 });
   if (jobs.length === 0) {
     logger.info("no approved writeback jobs available", { source_id: config.sourceId });
     return 0;
   }
   let completed = 0;
+  const report = async (job, result) => {
+    if (reportResult) await reportResult({ job, result, leaseId: job.cloud_lease.leaseId });
+    else await client.result(result, job.cloud_lease.leaseId);
+  };
   for (const job of jobs) {
     if (job.engine !== config.engine) {
-      await client.result({
-        protocol_version: "1.0",
-        job_id: job.job_id,
-        runner_id: config.runnerId,
-        status: "failed",
-        error_code: "DATABASE_UNAVAILABLE"
-      });
+      await report(job, failedWritebackResult(job, config.runnerId, "DATABASE_UNAVAILABLE"));
       continue;
     }
-    await client.heartbeat(job.job_id);
+    if (verifyAuthority) {
+      try {
+        await verifyAuthority(job);
+      } catch {
+        logger.warn("Cloud-approved job rejected by local reviewed authority", { job_id: job.job_id, error_code: "LOCAL_AUTHORITY_REJECTED" });
+        await report(job, failedWritebackResult(job, config.runnerId, "LOCAL_AUTHORITY_REJECTED"));
+        continue;
+      }
+    }
+    await client.heartbeat(job.job_id, job.cloud_lease.leaseId, config.runnerId);
     const result = await adapters2[config.engine].apply(job, config);
-    await client.result(result);
+    await report(job, result);
     completed += 1;
   }
   return completed;
 }
-async function startPolling(config, adapters2, signal) {
+async function startPolling(config, adapters2, signal, verifyAuthority, reportResult) {
   const logger = createLogger(config);
   while (!signal?.aborted) {
     try {
-      await runOnce(config, adapters2);
+      await runOnce(config, adapters2, verifyAuthority, reportResult);
     } catch (error) {
       logger.error("runner loop failed", { error: error instanceof Error ? error.message : String(error) });
     }
@@ -25679,6 +26101,12 @@ function quotePostgresIdentifier(identifier) {
 function operationOf(job) {
   return job.operation ?? "single_row_update";
 }
+function principalScope(job) {
+  const scope = job.target.principal_scope;
+  if (!scope) return void 0;
+  if (scope.value === void 0) throw new Error("PRINCIPAL_SCOPE_VALUE_REQUIRED");
+  return { column: scope.column, value: scope.value };
+}
 function receiptAuthority(config) {
   return config.receipts?.authority ?? "source_db";
 }
@@ -25710,6 +26138,11 @@ function buildPostgresUpdate(job) {
     `${quotePostgresIdentifier(job.target.primary_key.column)} = ${pkParam}`,
     `${quotePostgresIdentifier(job.target.tenant_guard.column)} = ${tenantParam}`
   ];
+  const scope = principalScope(job);
+  if (scope) {
+    values.push(scope.value);
+    where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+  }
   if (job.conflict_guard.kind === "version_column") {
     values.push(job.conflict_guard.expected_value);
     where.push(`${quotePostgresIdentifier(job.conflict_guard.column)} = $${values.length}`);
@@ -25742,13 +26175,20 @@ function buildPostgresDelete(job) {
   if (job.target.primary_key.value === void 0 || job.conflict_guard.kind !== "version_column") {
     throw new Error("postgres delete requires primary-key and exact version guards");
   }
-  return {
-    sql: `DELETE FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
-WHERE ${quotePostgresIdentifier(job.target.primary_key.column)} = $1
-  AND ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2
-  AND ${quotePostgresIdentifier(job.conflict_guard.column)} = $3`,
-    values: [job.target.primary_key.value, job.target.tenant_guard.value, job.conflict_guard.expected_value]
-  };
+  const values = [job.target.primary_key.value, job.target.tenant_guard.value];
+  const where = [
+    `${quotePostgresIdentifier(job.target.primary_key.column)} = $1`,
+    `${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2`
+  ];
+  const scope = principalScope(job);
+  if (scope) {
+    values.push(scope.value);
+    where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+  }
+  values.push(job.conflict_guard.expected_value);
+  where.push(`${quotePostgresIdentifier(job.conflict_guard.column)} = $${values.length}`);
+  return { sql: `DELETE FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
+WHERE ${where.join("\n  AND ")}`, values };
 }
 function validatePatch(job, engine) {
   const patchColumns = Object.keys(job.patch || {});
@@ -25756,6 +26196,8 @@ function validatePatch(job, engine) {
   const allowed = new Set(job.allowed_columns);
   if (allowed.has(job.target.primary_key.column)) throw new Error(`${engine} primary key column must not be patch-allowlisted`);
   if (allowed.has(job.target.tenant_guard.column)) throw new Error(`${engine} tenant guard column must not be patch-allowlisted`);
+  const scope = principalScope(job);
+  if (scope && allowed.has(scope.column)) throw new Error(`${engine} principal scope column must not be patch-allowlisted`);
   for (const column of patchColumns) if (!allowed.has(column)) throw new Error(`${engine} patch column not allowlisted: ${column}`);
 }
 function insertValues(job) {
@@ -25770,6 +26212,11 @@ function insertValues(job) {
     if (component.source === "proposal_id") proposalIdentity = true;
   }
   if (!trustedTenant || !proposalIdentity) throw new Error("INSERT_DEDUP_REQUIRED");
+  const scope = principalScope(job);
+  if (scope) {
+    if (Object.prototype.hasOwnProperty.call(values, scope.column)) throw new Error("PRINCIPAL_SCOPE_COLUMN_COLLISION");
+    values[scope.column] = scope.value;
+  }
   return values;
 }
 function identityForJob(job, insertedPrimaryKey) {
@@ -25794,6 +26241,8 @@ function digest(value) {
 }
 function reconciliationProjection(job) {
   const columns = /* @__PURE__ */ new Set([job.target.primary_key.column, job.target.tenant_guard.column, ...job.allowed_columns]);
+  const scope = principalScope(job);
+  if (scope) columns.add(scope.column);
   if (job.protocol_version === "3.0") {
     for (const member of job.frozen_set.members) {
       for (const column of Object.keys(member.before)) columns.add(column);
@@ -25815,41 +26264,70 @@ function reconciliationProjection(job) {
 function buildPostgresReconciliationRead(job) {
   const projection = reconciliationProjection(job).map(quotePostgresIdentifier).join(", ");
   if (job.protocol_version === "4.0") {
-    const values = [job.target.tenant_guard.value, ...job.compensation.members.map((member) => member.primary_key.value)];
+    const values2 = [job.target.tenant_guard.value];
+    const where2 = [`${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1`];
+    const scope2 = principalScope(job);
+    if (scope2) {
+      values2.push(scope2.value);
+      where2.push(`${quotePostgresIdentifier(scope2.column)} = $${values2.length}`);
+    }
+    const firstIdentity = values2.length + 1;
+    values2.push(...job.compensation.members.map((member) => member.primary_key.value));
     return {
       sql: `SELECT ${projection} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
-WHERE ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1
-  AND ${quotePostgresIdentifier(job.target.primary_key.column)} IN (${job.compensation.members.map((_, index) => `$${index + 2}`).join(", ")})
+WHERE ${where2.join("\n  AND ")}
+  AND ${quotePostgresIdentifier(job.target.primary_key.column)} IN (${job.compensation.members.map((_, index) => `$${firstIdentity + index}`).join(", ")})
 ORDER BY ${quotePostgresIdentifier(job.target.primary_key.column)} ASC`,
-      values
+      values: values2
     };
   }
   if (job.protocol_version === "3.0") {
-    const values = [job.target.tenant_guard.value, ...job.frozen_set.members.map((member) => member.primary_key.value)];
-    const identities = job.frozen_set.members.map((_, index) => `$${index + 2}`).join(", ");
+    const values2 = [job.target.tenant_guard.value];
+    const where2 = [`${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1`];
+    const scope2 = principalScope(job);
+    if (scope2) {
+      values2.push(scope2.value);
+      where2.push(`${quotePostgresIdentifier(scope2.column)} = $${values2.length}`);
+    }
+    const firstIdentity = values2.length + 1;
+    values2.push(...job.frozen_set.members.map((member) => member.primary_key.value));
+    const identities = job.frozen_set.members.map((_, index) => `$${firstIdentity + index}`).join(", ");
     return {
       sql: `SELECT ${projection} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
-WHERE ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1
+WHERE ${where2.join("\n  AND ")}
   AND ${quotePostgresIdentifier(job.target.primary_key.column)} IN (${identities})
 ORDER BY ${quotePostgresIdentifier(job.target.primary_key.column)} ASC`,
-      values
+      values: values2
     };
   }
   if (operationOf(job) === "single_row_insert" && job.protocol_version === "2.0" && job.deduplication) {
+    const values2 = job.deduplication.components.map((component) => component.value);
+    const where2 = job.deduplication.components.map((component, index) => `${quotePostgresIdentifier(component.column)} = $${index + 1}`);
+    const scope2 = principalScope(job);
+    if (scope2) {
+      values2.push(scope2.value);
+      where2.push(`${quotePostgresIdentifier(scope2.column)} = $${values2.length}`);
+    }
     return {
       sql: `SELECT ${projection} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
-WHERE ${job.deduplication.components.map((component, index) => `${quotePostgresIdentifier(component.column)} = $${index + 1}`).join(" AND ")}
+WHERE ${where2.join(" AND ")}
 LIMIT 2`,
-      values: job.deduplication.components.map((component) => component.value)
+      values: values2
     };
   }
   if (job.target.primary_key.value === void 0) throw new Error("RECONCILIATION_TARGET_IDENTITY_REQUIRED");
+  const values = [job.target.primary_key.value, job.target.tenant_guard.value];
+  const where = [`${quotePostgresIdentifier(job.target.primary_key.column)} = $1`, `${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2`];
+  const scope = principalScope(job);
+  if (scope) {
+    values.push(scope.value);
+    where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+  }
   return {
     sql: `SELECT ${projection} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
-WHERE ${quotePostgresIdentifier(job.target.primary_key.column)} = $1
-  AND ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2
+WHERE ${where.join("\n  AND ")}
 LIMIT 2`,
-    values: [job.target.primary_key.value, job.target.tenant_guard.value]
+    values
   };
 }
 async function inspectPostgresWritebackSource(job, databaseUrl) {
@@ -26109,6 +26587,8 @@ async function mutatePostgres(job, client) {
 }
 function compensationProjection(job) {
   const columns = /* @__PURE__ */ new Set([job.target.primary_key.column, job.target.tenant_guard.column]);
+  const scope = principalScope(job);
+  if (scope) columns.add(scope.column);
   for (const member of job.compensation.members) {
     for (const column of Object.keys(member.expected_state)) columns.add(column);
     for (const column of Object.keys(member.restore_values ?? {})) columns.add(column);
@@ -26117,9 +26597,18 @@ function compensationProjection(job) {
   return [...columns].sort();
 }
 async function lockPostgresCompensationMembers(job, client) {
+  const values = [job.target.tenant_guard.value];
+  const where = [`${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1`];
+  const scope = principalScope(job);
+  if (scope) {
+    values.push(scope.value);
+    where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+  }
+  const firstIdentity = values.length + 1;
+  values.push(...job.compensation.members.map((member) => member.primary_key.value));
   const result = await client.query(
-    `SELECT ${compensationProjection(job).map(quotePostgresIdentifier).join(", ")} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1 AND ${quotePostgresIdentifier(job.target.primary_key.column)} IN (${job.compensation.members.map((_, index) => `$${index + 2}`).join(", ")}) ORDER BY ${quotePostgresIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`,
-    [job.target.tenant_guard.value, ...job.compensation.members.map((member) => member.primary_key.value)]
+    `SELECT ${compensationProjection(job).map(quotePostgresIdentifier).join(", ")} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${where.join(" AND ")} AND ${quotePostgresIdentifier(job.target.primary_key.column)} IN (${job.compensation.members.map((_, index) => `$${firstIdentity + index}`).join(", ")}) ORDER BY ${quotePostgresIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`,
+    values
   );
   return result.rows;
 }
@@ -26163,6 +26652,8 @@ async function mutatePostgresCompensation(job, client) {
   if (job.operation === "restore_insert") {
     for (const member of job.compensation.members) {
       const values = { ...member.restore_values, [job.target.primary_key.column]: member.primary_key.value, [job.target.tenant_guard.column]: job.target.tenant_guard.value };
+      const scope = principalScope(job);
+      if (scope) values[scope.column] = scope.value;
       const columns = Object.keys(values).sort();
       const inserted = await client.query(
         `INSERT INTO ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} (${columns.map(quotePostgresIdentifier).join(", ")}) VALUES (${columns.map((_, index) => `$${index + 1}`).join(", ")})`,
@@ -26178,6 +26669,11 @@ async function mutatePostgresCompensation(job, client) {
         `${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1`,
         `${quotePostgresIdentifier(job.target.primary_key.column)} = $2`
       ];
+      const scope = principalScope(job);
+      if (scope) {
+        values.push(scope.value);
+        where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+      }
       for (const [column, value] of Object.entries(member.expected_state)) {
         values.push(value);
         where.push(`${quotePostgresIdentifier(column)} IS NOT DISTINCT FROM $${values.length}`);
@@ -26200,6 +26696,11 @@ async function mutatePostgresCompensation(job, client) {
       const where = [`${quotePostgresIdentifier(job.target.tenant_guard.column)} = $${values.length}`];
       values.push(member.primary_key.value);
       where.push(`${quotePostgresIdentifier(job.target.primary_key.column)} = $${values.length}`);
+      const scope = principalScope(job);
+      if (scope) {
+        values.push(scope.value);
+        where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+      }
       for (const [column, value] of Object.entries(member.expected_state)) {
         values.push(value);
         where.push(`${quotePostgresIdentifier(column)} IS NOT DISTINCT FROM $${values.length}`);
@@ -26254,18 +26755,35 @@ async function mutatePostgresSet(job, client) {
         return `${quotePostgresIdentifier(column)} = $${values.length}`;
       });
       assignments.push(`${quotePostgresIdentifier(job.version_advance.column)} = ${quotePostgresIdentifier(job.version_advance.column)} + 1`);
-      values.push(member.primary_key.value, job.target.tenant_guard.value, expected.value);
+      values.push(member.primary_key.value, job.target.tenant_guard.value);
+      const where = [
+        `${quotePostgresIdentifier(job.target.primary_key.column)} = $${values.length - 1}`,
+        `${quotePostgresIdentifier(job.target.tenant_guard.column)} = $${values.length}`
+      ];
+      const scope = principalScope(job);
+      if (scope) {
+        values.push(scope.value);
+        where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+      }
+      values.push(expected.value);
+      where.push(`${quotePostgresIdentifier(expected.column)} = $${values.length}`);
       const updated = await client.query(
-        `UPDATE ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} SET ${assignments.join(", ")} WHERE ${quotePostgresIdentifier(job.target.primary_key.column)} = $${values.length - 2} AND ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $${values.length - 1} AND ${quotePostgresIdentifier(expected.column)} = $${values.length}`,
+        `UPDATE ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} SET ${assignments.join(", ")} WHERE ${where.join(" AND ")}`,
         values
       );
       if (updated.rowCount !== 1) throw new Error("SET_ATOMICITY_VIOLATION");
       memberEffects.push({ primary_key: member.primary_key, before_digest: member.before_digest, after_digest: member.after_digest });
     } else {
-      const deleted = await client.query(
-        `DELETE FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${quotePostgresIdentifier(job.target.primary_key.column)} = $1 AND ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2 AND ${quotePostgresIdentifier(expected.column)} = $3`,
-        [member.primary_key.value, job.target.tenant_guard.value, expected.value]
-      );
+      const values = [member.primary_key.value, job.target.tenant_guard.value];
+      const where = [`${quotePostgresIdentifier(job.target.primary_key.column)} = $1`, `${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2`];
+      const scope = principalScope(job);
+      if (scope) {
+        values.push(scope.value);
+        where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+      }
+      values.push(expected.value);
+      where.push(`${quotePostgresIdentifier(expected.column)} = $${values.length}`);
+      const deleted = await client.query(`DELETE FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${where.join(" AND ")}`, values);
       if (deleted.rowCount !== 1) throw new Error("SET_ATOMICITY_VIOLATION");
       memberEffects.push({ primary_key: member.primary_key, before_digest: member.before_digest, tombstone_digest: member.tombstone_digest });
     }
@@ -26275,10 +26793,19 @@ async function mutatePostgresSet(job, client) {
 async function lockPostgresFrozenMembers(job, client) {
   const columns = /* @__PURE__ */ new Set([job.target.primary_key.column]);
   for (const member of job.frozen_set.members) for (const column of Object.keys(member.before)) columns.add(column);
-  const values = [job.target.tenant_guard.value, ...job.frozen_set.members.map((member) => member.primary_key.value)];
-  const placeholders = job.frozen_set.members.map((_, index) => `$${index + 2}`);
+  const values = [job.target.tenant_guard.value];
+  const where = [`${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1`];
+  const scope = principalScope(job);
+  if (scope) {
+    columns.add(scope.column);
+    values.push(scope.value);
+    where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+  }
+  const firstIdentity = values.length + 1;
+  values.push(...job.frozen_set.members.map((member) => member.primary_key.value));
+  const placeholders = job.frozen_set.members.map((_, index) => `$${firstIdentity + index}`);
   const result = await client.query(
-    `SELECT ${[...columns].map(quotePostgresIdentifier).join(", ")} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $1 AND ${quotePostgresIdentifier(job.target.primary_key.column)} IN (${placeholders.join(", ")}) ORDER BY ${quotePostgresIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`,
+    `SELECT ${[...columns].map(quotePostgresIdentifier).join(", ")} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${where.join(" AND ")} AND ${quotePostgresIdentifier(job.target.primary_key.column)} IN (${placeholders.join(", ")}) ORDER BY ${quotePostgresIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`,
     values
   );
   if (result.rowCount !== job.frozen_set.row_count) return false;
@@ -26300,16 +26827,23 @@ async function postgresDeleteSafetyCode(job, client) {
 function validateBatchInsertMember(job, member) {
   const dedupColumns = new Set(member.deduplication?.components.map((component) => component.column));
   for (const column of Object.keys(member.after)) {
-    if (!job.allowed_columns.includes(column) && !dedupColumns.has(column)) throw new Error("BATCH_COLUMN_NOT_ALLOWED");
+    if (!job.allowed_columns.includes(column) && !dedupColumns.has(column) && column !== job.target.principal_scope?.column) throw new Error("BATCH_COLUMN_NOT_ALLOWED");
   }
   if (!dedupColumns.has(job.target.primary_key.column) || !dedupColumns.has(job.target.tenant_guard.column)) throw new Error("BATCH_DEDUP_REQUIRED");
 }
 async function insertPostgresBatch(job, client) {
   for (const member of job.frozen_set.members) {
     const components = member.deduplication.components;
+    const values = components.map((component) => component.value);
+    const where = components.map((component, index) => `${quotePostgresIdentifier(component.column)} = $${index + 1}`);
+    const scope = principalScope(job);
+    if (scope) {
+      values.push(scope.value);
+      where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+    }
     const existing = await client.query(
-      `SELECT 1 FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${components.map((component, index) => `${quotePostgresIdentifier(component.column)} = $${index + 1}`).join(" AND ")} LIMIT 1 FOR UPDATE`,
-      components.map((component) => component.value)
+      `SELECT 1 FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${where.join(" AND ")} LIMIT 1 FOR UPDATE`,
+      values
     );
     if (existing.rowCount) return { status: "conflict", affectedRows: 0, code: "INSERT_DEDUP_CONFLICT", targetIdentity: identityForJob(job) };
   }
@@ -26333,12 +26867,18 @@ async function lockTargetRow(job, client) {
     ...job.conflict_guard.kind === "version_column" ? [`${quotePostgresIdentifier(job.conflict_guard.column)}::text AS "__synapsor_conflict_value"`] : [],
     ...inverseColumns.filter((column) => job.conflict_guard.kind !== "version_column" || column !== job.conflict_guard.column).map(quotePostgresIdentifier)
   ].join(", ");
+  const values = [job.target.primary_key.value, job.target.tenant_guard.value];
+  const where = [`${quotePostgresIdentifier(job.target.primary_key.column)} = $1`, `${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2`];
+  const scope = principalScope(job);
+  if (scope) {
+    values.push(scope.value);
+    where.push(`${quotePostgresIdentifier(scope.column)} = $${values.length}`);
+  }
   const result = await client.query(
     `SELECT ${projection} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
-WHERE ${quotePostgresIdentifier(job.target.primary_key.column)} = $1
-  AND ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2
+WHERE ${where.join("\n  AND ")}
 FOR UPDATE`,
-    [job.target.primary_key.value, job.target.tenant_guard.value]
+    values
   );
   return result.rowCount ? result.rows[0] : void 0;
 }
@@ -26346,8 +26886,14 @@ async function insertPostgres(job, client) {
   if (job.protocol_version !== "2.0" || !job.deduplication) throw new Error("INSERT_DEDUP_REQUIRED");
   const components = job.deduplication.components;
   const whereValues = components.map((component) => component.value);
+  const where = components.map((component, index) => `${quotePostgresIdentifier(component.column)} = $${index + 1}`);
+  const scope = principalScope(job);
+  if (scope) {
+    whereValues.push(scope.value);
+    where.push(`${quotePostgresIdentifier(scope.column)} = $${whereValues.length}`);
+  }
   const existing = await client.query(
-    `SELECT ${quotePostgresIdentifier(job.target.primary_key.column)}::text AS "__synapsor_primary_key" FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${components.map((component, index) => `${quotePostgresIdentifier(component.column)} = $${index + 1}`).join(" AND ")}`,
+    `SELECT ${quotePostgresIdentifier(job.target.primary_key.column)}::text AS "__synapsor_primary_key" FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)} WHERE ${where.join(" AND ")}`,
     whereValues
   );
   if (existing.rowCount) return { status: "conflict", affectedRows: 0, code: "INSERT_DEDUP_CONFLICT", targetIdentity: identityForJob(job, existing.rows[0]?.__synapsor_primary_key) };
@@ -26395,15 +26941,18 @@ function resultFromOutcome(job, config, outcome, overrideCode, overrideHash) {
   const operation = operationOf(job);
   const hash = overrideHash ?? resultHash(job, outcome.status, outcome.resultVersion);
   if (job.protocol_version === "4.0") {
-    return { protocol_version: "4.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob(job), member_effects: outcome.memberEffects ?? [], ...outcome.status === "applied" || outcome.status === "already_applied" ? { inverse: outcome.inverse ?? compensationInverseFromJob(job) } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+    return wireResult({ protocol_version: "4.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob(job), member_effects: outcome.memberEffects ?? [], ...outcome.status === "applied" || outcome.status === "already_applied" ? { inverse: outcome.inverse ?? compensationInverseFromJob(job) } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
   }
   if (job.protocol_version === "3.0") {
-    return { protocol_version: "3.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob(job), set_digest: job.frozen_set.set_digest, member_effects: outcome.memberEffects ?? [], ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+    return wireResult({ protocol_version: "3.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob(job), set_digest: job.frozen_set.set_digest, member_effects: outcome.memberEffects ?? [], ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
   }
   if (job.protocol_version !== "2.0") {
-    return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: outcome.status, affected_rows: outcome.affectedRows, result_version: outcome.resultVersion == null ? void 0 : String(outcome.resultVersion), result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+    return wireResult({ protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: outcome.status, affected_rows: outcome.affectedRows, result_version: outcome.resultVersion == null ? void 0 : String(outcome.resultVersion), result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
   }
-  return { protocol_version: "2.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identity: outcome.targetIdentity, result_version: outcome.resultVersion, before_digest: outcome.beforeDigest, after_digest: outcome.afterDigest, tombstone_digest: outcome.tombstoneDigest, ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+  return wireResult({ protocol_version: "2.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identity: outcome.targetIdentity, result_version: outcome.resultVersion, before_digest: outcome.beforeDigest, after_digest: outcome.afterDigest, tombstone_digest: outcome.tombstoneDigest, ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function wireResult(result) {
+  return Object.fromEntries(Object.entries(result).filter(([, value]) => value !== void 0));
 }
 function failedResult(job, config, code) {
   return resultFromOutcome(job, config, { status: "failed", affectedRows: 0, code, targetIdentity: identityForJob(job) });
@@ -26465,6 +27014,7 @@ var postgresAdapter = {
 import { DatabaseSync } from "node:sqlite";
 import { chmodSync, mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
+var SQLITE_BUSY_TIMEOUT_MS = 5e3;
 var PostgresWritebackIntentStore = class {
   pool;
   schema;
@@ -26675,6 +27225,12 @@ var PostgresProposalRuntimeStore = class {
   async getEvidenceBundle(evidenceBundleId) {
     return await this.withRead((store) => store.getEvidenceBundle(evidenceBundleId));
   }
+  async listEvidenceBundles(filters = {}) {
+    return await this.withRead((store) => store.listEvidenceBundles(filters));
+  }
+  async listQueryAudit(filters = {}) {
+    return await this.withRead((store) => store.listQueryAudit(filters));
+  }
   async replay(proposalId) {
     return await this.withWrite("replay", (store) => store.replay(proposalId));
   }
@@ -26690,6 +27246,33 @@ var PostgresProposalRuntimeStore = class {
   async requireWritebackReconciliation(intentId, reason) {
     await this.withWrite("requireWritebackReconciliation", (store) => store.requireWritebackReconciliation(intentId, reason));
   }
+  async enqueueCloudOutbox(input) {
+    return await this.withWrite("enqueueCloudOutbox", (store) => store.enqueueCloudOutbox(input));
+  }
+  async claimCloudOutbox(input) {
+    return await this.withWrite("claimCloudOutbox", (store) => store.claimCloudOutbox(input));
+  }
+  async acknowledgeCloudOutbox(eventId, owner, now) {
+    return await this.withWrite("acknowledgeCloudOutbox", (store) => store.acknowledgeCloudOutbox(eventId, owner, now));
+  }
+  async failCloudOutbox(input) {
+    return await this.withWrite("failCloudOutbox", (store) => store.failCloudOutbox(input));
+  }
+  async requeueCloudOutbox(eventId, now) {
+    return await this.withWrite("requeueCloudOutbox", (store) => store.requeueCloudOutbox(eventId, now));
+  }
+  async listCloudOutbox(filters = {}) {
+    return await this.withRead((store) => store.listCloudOutbox(filters));
+  }
+  async compactCloudOutbox(input) {
+    return await this.withWrite("compactCloudOutbox", (store) => store.compactCloudOutbox(input));
+  }
+  async recordCloudGovernanceEvent(input) {
+    return await this.withWrite("recordCloudGovernanceEvent", (store) => store.recordCloudGovernanceEvent(input));
+  }
+  async listCloudGovernanceEvents(proposalId) {
+    return await this.withRead((store) => store.listCloudGovernanceEvents(proposalId));
+  }
   async withRead(callback) {
     const store = await this.transientStoreFromPostgres(this.pool);
     try {
@@ -26885,6 +27468,7 @@ var ProposalStore = class {
       mkdirSync(dirname(resolve(path9)), { recursive: true, mode: 448 });
     }
     this.db = new DatabaseSync(path9);
+    this.db.exec(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
     if (path9 !== ":memory:" && process.platform !== "win32") {
       try {
         chmodSync(path9, 384);
@@ -26928,7 +27512,13 @@ var ProposalStore = class {
   pruneBefore(cutoffIso, options = {}) {
     const dryRun = options.dryRun !== false;
     const proposalIds = this.stringColumn(
-      "SELECT proposal_id FROM proposals WHERE created_at < ? AND state IN ('applied', 'conflict', 'rejected', 'canceled')",
+      `SELECT proposal_id FROM proposals
+       WHERE created_at < ? AND state IN ('applied', 'conflict', 'rejected', 'canceled')
+         AND NOT EXISTS (
+           SELECT 1 FROM cloud_outbox
+           WHERE cloud_outbox.proposal_id = proposals.proposal_id
+             AND cloud_outbox.status <> 'acknowledged'
+         )`,
       [cutoffIso],
       "proposal_id"
     );
@@ -26942,6 +27532,8 @@ var ProposalStore = class {
     const evidenceWhere = inWhere("evidence_bundle_id", evidenceIds);
     this.transaction(() => {
       if (proposalWhere) {
+        run("cloud_outbox", `${proposalWhere.sql} AND status = 'acknowledged'`, proposalWhere.params);
+        run("cloud_governance_events", proposalWhere.sql, proposalWhere.params);
         run("idempotency_receipts", proposalWhere.sql, proposalWhere.params);
         run("writeback_receipts", proposalWhere.sql, proposalWhere.params);
         run("writeback_jobs", proposalWhere.sql, proposalWhere.params);
@@ -26952,7 +27544,7 @@ var ProposalStore = class {
         run("worker_queue", proposalWhere.sql, proposalWhere.params);
         run("replay_records", proposalWhere.sql, proposalWhere.params);
       } else {
-        for (const table of ["idempotency_receipts", "writeback_receipts", "writeback_jobs", "writeback_intents", "approvals", "proposal_events", "shadow_human_actions", "worker_queue", "replay_records"]) {
+        for (const table of ["cloud_outbox", "cloud_governance_events", "idempotency_receipts", "writeback_receipts", "writeback_jobs", "writeback_intents", "approvals", "proposal_events", "shadow_human_actions", "worker_queue", "replay_records"]) {
           deleted[table] = 0;
         }
       }
@@ -27143,6 +27735,40 @@ var ProposalStore = class {
         updated_at TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS cloud_outbox (
+        event_id TEXT PRIMARY KEY,
+        proposal_id TEXT,
+        sequence INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        payload_hash TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        attempts INTEGER NOT NULL DEFAULT 0,
+        max_attempts INTEGER NOT NULL,
+        next_attempt_at TEXT NOT NULL,
+        lease_owner TEXT,
+        lease_expires_at TEXT,
+        last_error_code TEXT,
+        sent_at TEXT,
+        acknowledged_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY (proposal_id) REFERENCES proposals(proposal_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS cloud_governance_events (
+        event_id TEXT PRIMARY KEY,
+        proposal_id TEXT NOT NULL,
+        cloud_proposal_id TEXT,
+        kind TEXT NOT NULL,
+        state TEXT NOT NULL,
+        authority TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        integrity_hash TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (proposal_id) REFERENCES proposals(proposal_id)
+      );
+
       CREATE TABLE IF NOT EXISTS policy_recommendations (
         recommendation_id TEXT PRIMARY KEY,
         tenant_id TEXT NOT NULL,
@@ -27178,6 +27804,9 @@ var ProposalStore = class {
       CREATE INDEX IF NOT EXISTS idx_replay_records_proposal_id ON replay_records(proposal_id);
       CREATE INDEX IF NOT EXISTS idx_shadow_human_actions_proposal_id ON shadow_human_actions(proposal_id);
       CREATE INDEX IF NOT EXISTS idx_policy_recommendations_scope ON policy_recommendations(tenant_id, capability, policy, status, created_at);
+      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);
 
       INSERT OR IGNORE INTO proposal_store_schema(version, applied_at)
       VALUES (1, datetime('now'));
@@ -28060,6 +28689,7 @@ var ProposalStore = class {
       runner_scope: { project_id: options.project_id ?? "local", source_id: proposal.source_id },
       engine,
       tenant_guard: changeSet.guards.tenant,
+      ...changeSet.guards.principal_scope ? { principal_scope: changeSet.guards.principal_scope } : {},
       allowed_columns: changeSet.guards.allowed_columns,
       idempotency_key: `${proposal.proposal_id}:${proposal.object_id}`,
       lease
@@ -28105,6 +28735,7 @@ var ProposalStore = class {
         }
       },
       tenant_guard: changeSet.guards.tenant,
+      ...changeSet.guards.principal_scope ? { principal_scope: changeSet.guards.principal_scope } : {},
       allowed_columns: changeSet.guards.allowed_columns,
       patch: {},
       compensation: changeSet.compensation.descriptor,
@@ -28669,6 +29300,181 @@ var ProposalStore = class {
     if (!recommendation) throw new ProposalStoreError("POLICY_RECOMMENDATION_NOT_FOUND", `policy recommendation not found: ${recommendationId}`);
     return recommendation;
   }
+  enqueueCloudOutbox(input) {
+    const eventId = input.event_id.trim();
+    if (!eventId) throw new ProposalStoreError("CLOUD_OUTBOX_EVENT_ID_REQUIRED", "cloud outbox event_id is required");
+    if (!["proposal", "activity", "result"].includes(input.kind)) throw new ProposalStoreError("CLOUD_OUTBOX_KIND_INVALID", `unsupported Cloud outbox kind: ${input.kind}`);
+    if (input.proposal_id) this.requireProposal(input.proposal_id);
+    assertNoSecretMaterial(input.payload, `cloud_outbox.${eventId}`);
+    const payloadHash = canonicalJsonDigest(input.payload);
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const sequence = Math.max(0, Math.trunc(input.sequence ?? 0));
+    const maxAttempts = Math.max(1, Math.min(100, Math.trunc(input.max_attempts ?? 12)));
+    this.db.prepare(`
+      INSERT OR IGNORE INTO cloud_outbox (
+        event_id, proposal_id, sequence, kind, status, payload_hash, payload_json,
+        attempts, max_attempts, next_attempt_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, 'pending', ?, ?, 0, ?, ?, ?, ?)
+    `).run(eventId, input.proposal_id ?? null, sequence, input.kind, payloadHash, JSON.stringify(input.payload), maxAttempts, now, now, now);
+    const item = this.requireCloudOutboxItem(eventId);
+    if (item.payload_hash !== payloadHash || item.kind !== input.kind || item.proposal_id !== input.proposal_id) {
+      throw new ProposalStoreError("CLOUD_OUTBOX_IDEMPOTENCY_MISMATCH", `cloud outbox event ${eventId} was already recorded with different immutable content`);
+    }
+    return item;
+  }
+  claimCloudOutbox(input) {
+    const owner = input.owner.trim();
+    if (!owner) throw new ProposalStoreError("CLOUD_OUTBOX_OWNER_REQUIRED", "cloud outbox lease owner is required");
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const leaseExpiresAt = new Date(Date.parse(now) + Math.max(1e3, Math.min(3e5, input.lease_ms ?? 3e4))).toISOString();
+    const limit = Math.max(1, Math.min(100, Math.trunc(input.limit ?? 10)));
+    const claimed = [];
+    this.transaction(() => {
+      this.db.prepare(`
+        UPDATE cloud_outbox
+        SET status = 'pending', lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+        WHERE status = 'leased' AND lease_expires_at <= ?
+      `).run(now, now);
+      const rows = this.db.prepare(`
+        SELECT candidate.event_id
+        FROM cloud_outbox candidate
+        WHERE candidate.status = 'pending'
+          AND candidate.next_attempt_at <= ?
+          AND NOT EXISTS (
+            SELECT 1 FROM cloud_outbox earlier
+            WHERE earlier.proposal_id = candidate.proposal_id
+              AND earlier.sequence < candidate.sequence
+              AND earlier.status NOT IN ('acknowledged')
+          )
+        ORDER BY candidate.sequence ASC, candidate.created_at ASC, candidate.event_id ASC
+        LIMIT ?
+      `).all(now, limit);
+      for (const row of rows) {
+        if (!isRecord3(row) || typeof row.event_id !== "string") continue;
+        const result = this.db.prepare(`
+          UPDATE cloud_outbox
+          SET status = 'leased', lease_owner = ?, lease_expires_at = ?, attempts = attempts + 1,
+              sent_at = COALESCE(sent_at, ?), updated_at = ?
+          WHERE event_id = ? AND status = 'pending'
+        `).run(owner, leaseExpiresAt, now, now, row.event_id);
+        if (Number(result.changes) === 1) claimed.push(row.event_id);
+      }
+    });
+    return claimed.map((eventId) => this.requireCloudOutboxItem(eventId));
+  }
+  acknowledgeCloudOutbox(eventId, owner, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const result = this.db.prepare(`
+      UPDATE cloud_outbox
+      SET status = 'acknowledged', lease_owner = NULL, lease_expires_at = NULL,
+          acknowledged_at = ?, last_error_code = NULL, updated_at = ?
+      WHERE event_id = ? AND status = 'leased' AND lease_owner = ?
+    `).run(now, now, eventId, owner);
+    if (Number(result.changes) !== 1) throw new ProposalStoreError("CLOUD_OUTBOX_LEASE_MISMATCH", `cloud outbox event ${eventId} is not leased by ${owner}`);
+    return this.requireCloudOutboxItem(eventId);
+  }
+  failCloudOutbox(input) {
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    const current = this.requireCloudOutboxItem(input.event_id);
+    if (current.status !== "leased" || current.lease_owner !== input.owner) {
+      throw new ProposalStoreError("CLOUD_OUTBOX_LEASE_MISMATCH", `cloud outbox event ${input.event_id} is not leased by ${input.owner}`);
+    }
+    const exhausted = current.attempts >= current.max_attempts;
+    const status = input.reconciliation ? "reconciliation_required" : input.retryable && !exhausted ? "pending" : "dead_letter";
+    const fallbackDelay = Math.min(3e5, 500 * 2 ** Math.min(current.attempts, 9));
+    const delayMs = Math.max(0, Math.min(36e5, input.retry_after_ms ?? fallbackDelay));
+    const nextAttemptAt = new Date(Date.parse(now) + delayMs).toISOString();
+    this.db.prepare(`
+      UPDATE cloud_outbox
+      SET status = ?, lease_owner = NULL, lease_expires_at = NULL, last_error_code = ?,
+          next_attempt_at = ?, updated_at = ?
+      WHERE event_id = ?
+    `).run(status, input.error_code, nextAttemptAt, now, input.event_id);
+    return this.requireCloudOutboxItem(input.event_id);
+  }
+  requeueCloudOutbox(eventId, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const current = this.requireCloudOutboxItem(eventId);
+    if (!["dead_letter", "reconciliation_required"].includes(current.status)) {
+      throw new ProposalStoreError("CLOUD_OUTBOX_NOT_REQUEUEABLE", `cloud outbox event ${eventId} is ${current.status}, not dead_letter or reconciliation_required`);
+    }
+    this.db.prepare(`
+      UPDATE cloud_outbox
+      SET status = 'pending', attempts = 0, next_attempt_at = ?, lease_owner = NULL,
+          lease_expires_at = NULL, last_error_code = NULL, updated_at = ?
+      WHERE event_id = ?
+    `).run(now, now, eventId);
+    return this.requireCloudOutboxItem(eventId);
+  }
+  listCloudOutbox(filters = {}) {
+    const conditions = [];
+    const values = [];
+    if (filters.status) {
+      conditions.push("status = ?");
+      values.push(filters.status);
+    }
+    if (filters.proposal_id) {
+      conditions.push("proposal_id = ?");
+      values.push(filters.proposal_id);
+    }
+    const limit = Math.max(1, Math.min(1e4, Math.trunc(filters.limit ?? 100)));
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    return this.db.prepare(`SELECT * FROM cloud_outbox ${where} ORDER BY sequence ASC, created_at ASC, event_id ASC LIMIT ?`).all(...values, limit).map(rowToCloudOutboxItem).filter((item) => item !== void 0);
+  }
+  compactCloudOutbox(input) {
+    const result = this.db.prepare("DELETE FROM cloud_outbox WHERE status = 'acknowledged' AND acknowledged_at < ?").run(input.acknowledged_before);
+    return Number(result.changes);
+  }
+  recordCloudGovernanceEvent(input) {
+    this.requireProposal(input.proposal_id);
+    assertNoSecretMaterial(input.payload, `cloud_governance_event.${input.event_id}`);
+    const createdAt = input.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+    const unsigned = {
+      event_id: input.event_id,
+      proposal_id: input.proposal_id,
+      ...input.cloud_proposal_id ? { cloud_proposal_id: input.cloud_proposal_id } : {},
+      kind: input.kind,
+      state: input.state,
+      authority: "synapsor_cloud",
+      payload: input.payload,
+      created_at: createdAt
+    };
+    const event = { ...unsigned, integrity_hash: canonicalJsonDigest(unsigned) };
+    this.db.prepare(`
+      INSERT OR IGNORE INTO cloud_governance_events (
+        event_id, proposal_id, cloud_proposal_id, kind, state, authority, payload_json, integrity_hash, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(event.event_id, event.proposal_id, event.cloud_proposal_id ?? null, event.kind, event.state, event.authority, JSON.stringify(event.payload), event.integrity_hash, event.created_at);
+    const localState = localStateFromCloudGovernance(event.state);
+    if (localState) {
+      const sourceMutated = localState === "applied" ? 1 : 0;
+      const projected = this.db.prepare(`
+        UPDATE proposals
+        SET state = ?, source_database_mutated = CASE WHEN ? = 1 THEN 1 ELSE source_database_mutated END, updated_at = ?
+        WHERE proposal_id = ? AND state IN ('pending_review', 'approved', 'pending_worker')
+      `).run(localState, sourceMutated, event.created_at, event.proposal_id);
+      if (Number(projected.changes) === 1) {
+        this.appendEvent(event.proposal_id, `proposal_cloud_${localState}`, "synapsor_cloud", {
+          cloud_event_id: event.event_id,
+          cloud_proposal_id: event.cloud_proposal_id ?? event.proposal_id,
+          cloud_state: event.state,
+          authority: event.authority
+        });
+      }
+    }
+    const stored = this.listCloudGovernanceEvents(input.proposal_id).find((item) => item.event_id === input.event_id);
+    if (!stored || stored.integrity_hash !== event.integrity_hash) {
+      throw new ProposalStoreError("CLOUD_GOVERNANCE_EVENT_MISMATCH", `Cloud governance event ${input.event_id} conflicts with an existing immutable event`);
+    }
+    return stored;
+  }
+  listCloudGovernanceEvents(proposalId) {
+    const rows = proposalId ? this.db.prepare("SELECT * FROM cloud_governance_events WHERE proposal_id = ? ORDER BY created_at ASC, event_id ASC").all(proposalId) : this.db.prepare("SELECT * FROM cloud_governance_events ORDER BY created_at ASC, event_id ASC").all();
+    return rows.map(rowToCloudGovernanceEvent).filter((item) => item !== void 0);
+  }
+  requireCloudOutboxItem(eventId) {
+    const item = rowToCloudOutboxItem(this.db.prepare("SELECT * FROM cloud_outbox WHERE event_id = ?").get(eventId));
+    if (!item) throw new ProposalStoreError("CLOUD_OUTBOX_EVENT_NOT_FOUND", `cloud outbox event not found: ${eventId}`);
+    return item;
+  }
   setRunnerState(key, value) {
     assertNoSecretMaterial(value, `runner_state.${key}`);
     this.db.prepare(`
@@ -28698,7 +29504,9 @@ var ProposalStore = class {
       { table: "shadow_human_actions", kind: "shadow_human_action", key: "action_id", created: "created_at", proposal: "proposal_id" },
       { table: "worker_queue", kind: "worker_queue_item", key: "proposal_id", created: "created_at", proposal: "proposal_id" },
       { 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: "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" },
+      { table: "cloud_governance_events", kind: "cloud_governance_event", key: "event_id", created: "created_at", proposal: "proposal_id" }
     ];
     const entries = [];
     for (const spec of specs) {
@@ -29151,6 +29959,15 @@ function stateFromReceipt(receipt) {
   if (receipt.status === "reconciliation_required") return "reconciliation_required";
   return "failed";
 }
+function localStateFromCloudGovernance(state) {
+  if (state === "applied" || state === "already_applied") return "applied";
+  if (state === "rejected") return "rejected";
+  if (state === "canceled") return "canceled";
+  if (state === "conflict") return "conflict";
+  if (state === "failed") return "failed";
+  if (state === "indeterminate" || state === "reconciliation_required") return "reconciliation_required";
+  return void 0;
+}
 function receiptToWritebackResult(receipt) {
   if (receipt.schema_version === protocolVersions.executionReceiptV4) {
     return parseWritebackResult({
@@ -29223,6 +30040,7 @@ function inverseCaptureFromChangeSet(changeSet, writebackJobId) {
       primary_key_column: changeSet.source.primary_key.column
     },
     tenant_guard: changeSet.guards.tenant,
+    ...changeSet.guards.principal_scope ? { principal_scope: changeSet.guards.principal_scope } : {},
     allowed_columns: changeSet.guards.allowed_columns,
     lineage: changeSet.reversibility.lineage
   };
@@ -29248,7 +30066,7 @@ function inverseCaptureFromChangeSet(changeSet, writebackJobId) {
         operation: "remove_insert",
         members: [{
           primary_key: { column: changeSet.source.primary_key.column, value: primaryValue },
-          expected_state: selectReviewedState(changeSet.after, [changeSet.source.primary_key.column, changeSet.guards.tenant.column, ...changeSet.guards.allowed_columns])
+          expected_state: selectReviewedState(changeSet.after, [changeSet.source.primary_key.column, changeSet.guards.tenant.column, ...changeSet.guards.principal_scope ? [changeSet.guards.principal_scope.column] : [], ...changeSet.guards.allowed_columns])
         }],
         max_rows: 1,
         aggregate_bounds: []
@@ -29528,6 +30346,45 @@ function rowToWorkerQueueItem(row) {
     updated_at: String(row.updated_at)
   };
 }
+function rowToCloudOutboxItem(row) {
+  if (!isRecord3(row)) return void 0;
+  const kind = String(row.kind);
+  const status = String(row.status);
+  if (!["proposal", "activity", "result"].includes(kind) || !["pending", "leased", "acknowledged", "dead_letter", "reconciliation_required"].includes(status)) return void 0;
+  return {
+    event_id: String(row.event_id),
+    proposal_id: row.proposal_id == null ? void 0 : String(row.proposal_id),
+    sequence: Number(row.sequence),
+    kind,
+    status,
+    payload_hash: String(row.payload_hash),
+    payload: JSON.parse(String(row.payload_json)),
+    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_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),
+    sent_at: row.sent_at == null ? void 0 : String(row.sent_at),
+    acknowledged_at: row.acknowledged_at == null ? void 0 : String(row.acknowledged_at),
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
+  };
+}
+function rowToCloudGovernanceEvent(row) {
+  if (!isRecord3(row) || String(row.authority) !== "synapsor_cloud") return void 0;
+  return {
+    event_id: String(row.event_id),
+    proposal_id: String(row.proposal_id),
+    cloud_proposal_id: row.cloud_proposal_id == null ? void 0 : String(row.cloud_proposal_id),
+    kind: String(row.kind),
+    state: String(row.state),
+    authority: "synapsor_cloud",
+    payload: JSON.parse(String(row.payload_json)),
+    integrity_hash: String(row.integrity_hash),
+    created_at: String(row.created_at)
+  };
+}
 function rowToReceipt(row) {
   if (!isRecord3(row)) return void 0;
   return {
@@ -29687,7 +30544,9 @@ var sharedLedgerKindToTable = {
   shadow_human_action: "shadow_human_actions",
   worker_queue_item: "worker_queue",
   runner_state: "runner_state",
-  policy_recommendation: "policy_recommendations"
+  policy_recommendation: "policy_recommendations",
+  cloud_outbox_event: "cloud_outbox",
+  cloud_governance_event: "cloud_governance_events"
 };
 var sharedLedgerRestoreSpecs = {
   proposals: restoreSpec("proposal_id", [
@@ -29725,7 +30584,9 @@ var sharedLedgerRestoreSpecs = {
   shadow_human_actions: restoreSpec("action_id", ["action_id", "proposal_id", "actor", "patch_json", "notes", "created_at"], ["action_id", "proposal_id", "actor", "patch_json", "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"]),
   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"])
+  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"]),
+  cloud_governance_events: restoreSpec("event_id", ["event_id", "proposal_id", "cloud_proposal_id", "kind", "state", "authority", "payload_json", "integrity_hash", "created_at"], ["event_id", "proposal_id", "kind", "state", "authority", "payload_json", "integrity_hash", "created_at"])
 };
 function sharedLedgerPayload(table, row) {
   const payload = { table };
@@ -29768,7 +30629,9 @@ function sharedLedgerRestoreRank(entry) {
     "shadow_human_actions",
     "worker_queue",
     "runner_state",
-    "policy_recommendations"
+    "policy_recommendations",
+    "cloud_outbox",
+    "cloud_governance_events"
   ];
   const table = sharedLedgerTableForEntry(entry);
   const index = table ? order.indexOf(table) : -1;
@@ -29858,7 +30721,7 @@ var RESOURCE_KEYS = /* @__PURE__ */ new Set(["name", "engine", "schema", "table"
 var CONTEXT_KEYS2 = /* @__PURE__ */ new Set(["name", "description", "bindings", "tenant_binding", "principal_binding"]);
 var BINDING_KEYS = /* @__PURE__ */ new Set(["name", "source", "key", "required"]);
 var CAPABILITY_KEYS2 = /* @__PURE__ */ new Set(["name", "description", "returns_hint", "kind", "context", "source", "subject", "args", "lookup", "visible_fields", "kept_out_fields", "evidence", "max_rows", "proposal", "aggregate"]);
-var SUBJECT_KEYS = /* @__PURE__ */ new Set(["resource", "schema", "table", "primary_key", "tenant_key", "conflict_key", "single_tenant_dev"]);
+var SUBJECT_KEYS = /* @__PURE__ */ new Set(["resource", "schema", "table", "primary_key", "tenant_key", "principal_scope_key", "conflict_key", "single_tenant_dev"]);
 var ARG_KEYS2 = /* @__PURE__ */ new Set(["type", "description", "required", "max_length", "minimum", "maximum", "enum", "max_items", "fields"]);
 var LOOKUP_KEYS2 = /* @__PURE__ */ new Set(["id_from_arg"]);
 var EVIDENCE_KEYS = /* @__PURE__ */ new Set(["required", "sources", "query_audit", "handle_prefix"]);
@@ -29927,6 +30790,7 @@ function validateContract(input) {
   const capabilities = Array.isArray(input.capabilities) ? input.capabilities : [];
   const policies = Array.isArray(input.policies) ? input.policies : [];
   const capabilityNames = validateCapabilities2(input.capabilities, contextNames, resourceNames, errors, warnings);
+  validatePrincipalScopes(input.capabilities, input.contexts, input.resources, errors);
   validateWorkflows(input.workflows, contextNames, capabilityNames, errors);
   const policyByName = validatePolicies2(input.policies, errors);
   validateCapabilityApprovalPolicies(capabilities, policies, policyByName, errors);
@@ -30154,9 +31018,66 @@ function validateSubject(value, path9, resourceNames, errors, warnings) {
       errors.push({ path: `${path9}.tenant_key`, code: "TENANT_KEY_REQUIRED", message: "tenant_key is required unless single_tenant_dev is explicitly true." });
     }
   }
+  if (value.principal_scope_key !== void 0 && !isSafeIdentifier2(value.principal_scope_key)) {
+    errors.push({ path: `${path9}.principal_scope_key`, code: "INVALID_PRINCIPAL_SCOPE_KEY", message: "principal_scope_key must be a fixed safe identifier." });
+  }
+  if (value.principal_scope_key !== void 0 && value.resource === void 0 && !isSafeIdentifier2(value.tenant_key)) {
+    errors.push({ path: `${path9}.principal_scope_key`, code: "PRINCIPAL_SCOPE_TENANT_REQUIRED", message: "principal_scope_key can only narrow a capability that also declares tenant_key." });
+  }
+  if (value.principal_scope_key !== void 0 && value.single_tenant_dev === true) {
+    errors.push({ path: `${path9}.principal_scope_key`, code: "PRINCIPAL_SCOPE_TENANT_REQUIRED", message: "principal_scope_key cannot be used with single_tenant_dev; declare a reviewed tenant_key." });
+  }
   if (value.single_tenant_dev === true)
     warnings.push({ path: `${path9}.single_tenant_dev`, code: "SINGLE_TENANT_DEV", message: "single_tenant_dev is only for local demos and must not be used for shared tenant data." });
 }
+function validatePrincipalScopes(capabilities, contexts, resources, errors) {
+  if (!Array.isArray(capabilities) || !Array.isArray(contexts))
+    return;
+  const contextByName = /* @__PURE__ */ new Map();
+  const resourceByName = /* @__PURE__ */ new Map();
+  for (const context of contexts) {
+    if (isRecord4(context) && isNonEmptyString2(context.name))
+      contextByName.set(context.name, context);
+  }
+  if (Array.isArray(resources)) {
+    for (const resource of resources) {
+      if (isRecord4(resource) && isNonEmptyString2(resource.name))
+        resourceByName.set(resource.name, resource);
+    }
+  }
+  capabilities.forEach((capability, index) => {
+    if (!isRecord4(capability) || !isRecord4(capability.subject) || capability.subject.principal_scope_key === void 0)
+      return;
+    const path9 = `$.capabilities[${index}]`;
+    const resource = typeof capability.subject.resource === "string" ? resourceByName.get(capability.subject.resource) : void 0;
+    const tenantKey = capability.subject.tenant_key ?? resource?.tenant_key;
+    const singleTenantDev = capability.subject.single_tenant_dev ?? resource?.single_tenant_dev;
+    if (!isSafeIdentifier2(tenantKey) || singleTenantDev === true) {
+      errors.push({ path: `${path9}.subject.principal_scope_key`, code: "PRINCIPAL_SCOPE_TENANT_REQUIRED", message: "principal_scope_key can only narrow a capability with a reviewed tenant_key." });
+    }
+    const context = contextByName.get(String(capability.context));
+    if (!context || !isSafeIdentifier2(context.principal_binding)) {
+      errors.push({ path: `${path9}.context`, code: "PRINCIPAL_SCOPE_BINDING_REQUIRED", message: "principal-scoped capabilities require a context with principal_binding." });
+      return;
+    }
+    const binding = Array.isArray(context.bindings) ? context.bindings.find((item) => isRecord4(item) && item.name === context.principal_binding) : void 0;
+    if (!isRecord4(binding) || binding.required !== true) {
+      errors.push({ path: `${path9}.context`, code: "PRINCIPAL_SCOPE_BINDING_REQUIRED", message: "principal_binding must reference a required trusted context binding." });
+    }
+    const scopeKey = capability.subject.principal_scope_key;
+    if (isRecord4(capability.args) && Object.prototype.hasOwnProperty.call(capability.args, String(scopeKey))) {
+      errors.push({ path: `${path9}.args.${String(scopeKey)}`, code: "MODEL_CONTROLLED_PRINCIPAL_SCOPE", message: "the reviewed principal scope column cannot also be a model-facing argument." });
+    }
+    if (isRecord4(capability.proposal)) {
+      if (Array.isArray(capability.proposal.allowed_fields) && capability.proposal.allowed_fields.includes(scopeKey)) {
+        errors.push({ path: `${path9}.proposal.allowed_fields`, code: "PRINCIPAL_SCOPE_WRITE_FORBIDDEN", message: "the reviewed principal scope column cannot be model-writeable." });
+      }
+      if (isRecord4(capability.proposal.patch) && Object.prototype.hasOwnProperty.call(capability.proposal.patch, String(scopeKey))) {
+        errors.push({ path: `${path9}.proposal.patch.${String(scopeKey)}`, code: "PRINCIPAL_SCOPE_WRITE_FORBIDDEN", message: "the reviewed principal scope column is forced from trusted context and cannot be patched by the model." });
+      }
+    }
+  });
+}
 function validateArgs2(value, path9, errors, allowEmpty = false) {
   if (!isRecord4(value) || !allowEmpty && Object.keys(value).length === 0) {
     errors.push({ path: path9, code: "ARGS_REQUIRED", message: "args must define at least one model-facing business argument." });
@@ -32778,7 +33699,10 @@ function loadRuntimeConfigFromFile(configPath = process.env.SYNAPSOR_MCP_CONFIG
   return config;
 }
 function resolveRuntimeConfig(config, baseDir = process.cwd()) {
-  if (!Array.isArray(config.contracts) || config.contracts.length === 0) return config;
+  const governance = config.governance?.connection_file ? { ...config.governance, connection_file: path2.resolve(baseDir, config.governance.connection_file) } : config.governance;
+  if (!Array.isArray(config.contracts) || config.contracts.length === 0) {
+    return governance === config.governance ? config : { ...config, governance };
+  }
   const seenCapabilities = /* @__PURE__ */ new Map();
   const seenPolicies = /* @__PURE__ */ new Map();
   for (const [index, capability] of (config.capabilities ?? []).entries()) {
@@ -32789,6 +33713,7 @@ function resolveRuntimeConfig(config, baseDir = process.cwd()) {
   }
   const resolved = {
     ...config,
+    ...governance ? { governance } : {},
     contexts: { ...config.contexts ?? {} },
     capabilities: [...config.capabilities ?? []],
     policies: [...config.policies ?? []]
@@ -32801,6 +33726,490 @@ function resolveRuntimeConfig(config, baseDir = process.cwd()) {
   delete resolved.contracts;
   return resolved;
 }
+function loadCloudLinkedConnection(config, env = process.env) {
+  if (config.governance?.mode !== "cloud_linked") {
+    throw new McpRuntimeError("CLOUD_LINKED_MODE_REQUIRED", "This operation requires governance.mode cloud_linked.");
+  }
+  const connectionPath = config.governance.connection_file;
+  if (!connectionPath) throw new McpRuntimeError("CLOUD_CONNECTION_REQUIRED", "Cloud-linked governance requires governance.connection_file.");
+  let parsed;
+  try {
+    parsed = JSON.parse(fs2.readFileSync(connectionPath, "utf8"));
+  } catch (error) {
+    throw new McpRuntimeError("CLOUD_CONNECTION_INVALID", `Unable to read the reviewed Cloud connection file: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const root = isRecord5(parsed) ? parsed : {};
+  const cloud2 = isRecord5(root.cloud) ? root.cloud : void 0;
+  if (!cloud2) throw new McpRuntimeError("CLOUD_CONNECTION_INVALID", "Cloud connection file must contain a cloud object.");
+  const baseUrlEnv = nonEmptyString(cloud2.base_url_env) ?? "SYNAPSOR_CLOUD_BASE_URL";
+  const runnerTokenEnv = nonEmptyString(cloud2.runner_token_env) ?? "SYNAPSOR_RUNNER_TOKEN";
+  const baseUrl = envValue(env, baseUrlEnv) ?? nonEmptyString(cloud2.base_url);
+  const runnerToken = envValue(env, runnerTokenEnv);
+  const sourceId = nonEmptyString(cloud2.source_id);
+  const runnerSourceId = nonEmptyString(cloud2.runner_source_id) ?? sourceId;
+  const projectId = nonEmptyString(cloud2.project_id);
+  const contractId = nonEmptyString(cloud2.contract_id);
+  const contractVersionId = nonEmptyString(cloud2.contract_version_id);
+  const digest3 = nonEmptyString(cloud2.contract_digest);
+  const missing = [
+    !baseUrl ? baseUrlEnv : "",
+    !runnerToken ? runnerTokenEnv : "",
+    !projectId ? "cloud.project_id" : "",
+    !sourceId ? "cloud.source_id" : "",
+    !contractId ? "cloud.contract_id" : "",
+    !contractVersionId ? "cloud.contract_version_id" : "",
+    !digest3 ? "cloud.contract_digest" : ""
+  ].filter(Boolean);
+  if (missing.length) throw new McpRuntimeError("CLOUD_CONNECTION_INCOMPLETE", `Cloud-linked connection is missing: ${missing.join(", ")}.`);
+  if (!/^sha256:[0-9a-f]{64}$/i.test(digest3)) throw new McpRuntimeError("CLOUD_CONTRACT_DIGEST_INVALID", "cloud.contract_digest must be a full sha256 digest.");
+  let normalizedBaseUrl;
+  try {
+    const url = new URL(baseUrl);
+    if (!/^https?:$/.test(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("unsafe URL components");
+    normalizedBaseUrl = url.toString().replace(/\/$/, "");
+  } catch {
+    throw new McpRuntimeError("CLOUD_BASE_URL_INVALID", `${baseUrlEnv} must contain an HTTP(S) origin without credentials, query, or fragment.`);
+  }
+  return {
+    protocol_version: nonEmptyString(cloud2.protocol_version) ?? protocolVersions.runnerProposal,
+    base_url: normalizedBaseUrl,
+    runner_token_env: runnerTokenEnv,
+    runner_token: runnerToken,
+    runner_id: nonEmptyString(cloud2.runner_id) ?? envValue(env, "SYNAPSOR_RUNNER_ID") ?? "synapsor_runner_local",
+    runner_version: nonEmptyString(cloud2.runner_version) ?? envValue(env, "npm_package_version") ?? "unknown",
+    project_id: projectId,
+    source_id: sourceId,
+    runner_source_id: runnerSourceId,
+    ...nonEmptyString(cloud2.mapping_id) ? { mapping_id: nonEmptyString(cloud2.mapping_id) } : {},
+    contract_id: contractId,
+    contract_version_id: contractVersionId,
+    contract_digest: digest3.toLowerCase()
+  };
+}
+async function enqueueCloudLinkedProposal(input) {
+  if (input.config.governance?.mode !== "cloud_linked") return void 0;
+  if (!input.store.enqueueCloudOutbox) throw new McpRuntimeError("CLOUD_OUTBOX_UNAVAILABLE", "The configured runtime store does not implement the durable Cloud outbox.");
+  const connection = loadCloudLinkedConnection(input.config, input.env ?? process.env);
+  if (input.proposal.source_id !== connection.runner_source_id) {
+    throw new McpRuntimeError("CLOUD_SOURCE_MAPPING_MISMATCH", `Proposal source ${input.proposal.source_id} is not the reviewed local source ${connection.runner_source_id}.`);
+  }
+  const evidence2 = input.store.listEvidenceBundles ? await input.store.listEvidenceBundles({ proposal: input.proposal.proposal_id, limit: 100 }) : [];
+  const queryAudit2 = input.store.listQueryAudit ? await input.store.listQueryAudit({ proposal: input.proposal.proposal_id, limit: 100 }) : [];
+  const sanitizedChangeSet = cloudSafeChangeSet(input.proposal.change_set);
+  const proposalPayload = {
+    schema_version: protocolVersions.runnerProposal,
+    runner_id: connection.runner_id,
+    source_id: connection.source_id,
+    ...connection.mapping_id ? { mapping_id: connection.mapping_id } : {},
+    contract: {
+      contract_id: connection.contract_id,
+      contract_version_id: connection.contract_version_id,
+      digest: connection.contract_digest
+    },
+    change_set: sanitizedChangeSet,
+    evidence_metadata: {
+      bundle_ids: evidence2.length ? evidence2.map((item) => item.evidence_bundle_id) : [input.evidenceBundleId],
+      count: evidence2.length || 1,
+      query_fingerprints: [...new Set([input.queryFingerprint, ...evidence2.map((item) => item.query_fingerprint)].filter((value) => Boolean(value)))],
+      payload_uploaded: false
+    },
+    query_audit: {
+      audit_ids: queryAudit2.map((item) => item.audit_id).filter((value) => value !== void 0),
+      count: queryAudit2.length,
+      query_fingerprints: [...new Set(queryAudit2.map((item) => typeof item.query_fingerprint === "string" ? item.query_fingerprint : void 0).filter((value) => Boolean(value)))],
+      tables: [...new Set(queryAudit2.map((item) => typeof item.table_name === "string" ? item.table_name : void 0).filter((value) => Boolean(value)))],
+      payload_uploaded: false
+    }
+  };
+  const maxAttempts = input.config.governance.max_attempts ?? 12;
+  const proposalItem = await input.store.enqueueCloudOutbox({
+    event_id: `cloud-proposal:${input.proposal.proposal_id}`,
+    proposal_id: input.proposal.proposal_id,
+    sequence: 0,
+    kind: "proposal",
+    payload: proposalPayload,
+    max_attempts: maxAttempts
+  });
+  const principalScope3 = input.proposal.change_set.guards.principal_scope;
+  const common = {
+    schema_version: protocolVersions.runnerActivity,
+    runner_id: connection.runner_id,
+    source_id: connection.source_id,
+    proposal_id: input.proposal.proposal_id,
+    capability: input.proposal.action,
+    tenant_id: input.proposal.tenant_id,
+    principal: principalScope3?.value_fingerprint ?? input.proposal.principal,
+    business_object: input.proposal.business_object,
+    object_id: input.proposal.object_id,
+    status: "pending_cloud_sync"
+  };
+  for (const [index, bundle] of evidence2.entries()) {
+    const activity2 = {
+      ...common,
+      event_id: `evidence:${input.proposal.proposal_id}:${bundle.evidence_bundle_id}`,
+      event_type: "evidence.recorded",
+      evidence_ids: [bundle.evidence_bundle_id],
+      detail: { residency: "metadata_only", stored_locally: true, payload_uploaded: false },
+      occurred_at: bundle.created_at
+    };
+    await input.store.enqueueCloudOutbox({ event_id: `cloud-activity:${activity2.event_id}`, proposal_id: input.proposal.proposal_id, sequence: 10 + index, kind: "activity", payload: activity2, max_attempts: maxAttempts });
+  }
+  for (const [index, audit2] of queryAudit2.entries()) {
+    const auditId = String(audit2.audit_id);
+    const activity2 = {
+      ...common,
+      event_id: `query-audit:${input.proposal.proposal_id}:${auditId}`,
+      event_type: "query_audit.recorded",
+      query_audit_ids: [auditId],
+      ...typeof audit2.evidence_bundle_id === "string" ? { evidence_ids: [audit2.evidence_bundle_id] } : {},
+      detail: { residency: "metadata_only", stored_locally: true, payload_uploaded: false },
+      occurred_at: typeof audit2.created_at === "string" ? audit2.created_at : void 0
+    };
+    await input.store.enqueueCloudOutbox({ event_id: `cloud-activity:${activity2.event_id}`, proposal_id: input.proposal.proposal_id, sequence: 20 + index, kind: "activity", payload: activity2, max_attempts: maxAttempts });
+  }
+  await input.store.recordCloudGovernanceEvent?.({
+    event_id: `cloud-governance:pending:${input.proposal.proposal_id}`,
+    proposal_id: input.proposal.proposal_id,
+    kind: "proposal.pending_cloud_sync",
+    state: "pending_cloud_sync",
+    payload: { evidence_residency: "metadata_only", contract_digest: connection.contract_digest, project_id: connection.project_id, source_id: connection.source_id }
+  });
+  return proposalItem;
+}
+async function enqueueCloudLinkedResult(input) {
+  if (input.config.governance?.mode !== "cloud_linked") return void 0;
+  if (!input.store.enqueueCloudOutbox) throw new McpRuntimeError("CLOUD_OUTBOX_UNAVAILABLE", "The configured runtime store does not implement the durable Cloud outbox.");
+  if (input.result.job_id !== `wbj_${input.proposalId}` && !input.result.job_id.endsWith(input.proposalId)) {
+    throw new McpRuntimeError("CLOUD_RESULT_PROPOSAL_MISMATCH", "Cloud result job identity does not match the local proposal.");
+  }
+  const proposal = await input.store.getProposal(input.proposalId);
+  const localAuthorityRejected = input.result.status === "failed" && input.result.affected_rows === 0 && input.result.error_code === "LOCAL_AUTHORITY_REJECTED";
+  if (!proposal && !localAuthorityRejected) {
+    throw new McpRuntimeError("CLOUD_RESULT_LOCAL_PROPOSAL_REQUIRED", `Cloud result ${input.result.job_id} has no matching local proposal.`);
+  }
+  const payload = {
+    schema_version: "synapsor.cloud-result-outbox.v1",
+    lease_id: input.leaseId,
+    result: input.result
+  };
+  return input.store.enqueueCloudOutbox({
+    event_id: `cloud-result:${input.result.job_id}:${input.result.result_hash}`,
+    ...proposal ? { proposal_id: input.proposalId } : {},
+    sequence: 1e3,
+    kind: "result",
+    payload,
+    max_attempts: input.config.governance.max_attempts ?? 12
+  });
+}
+async function assertCloudLinkedProposalAvailability(config, env) {
+  if (config.governance?.mode !== "cloud_linked" || config.governance.queue_when_unavailable !== false) return;
+  const connection = loadCloudLinkedConnection(config, env);
+  const client = new ControlPlaneClient({
+    baseUrl: connection.base_url,
+    runnerToken: connection.runner_token,
+    sourceId: connection.source_id,
+    runnerId: connection.runner_id
+  });
+  let result;
+  try {
+    result = await client.doctor();
+  } catch (error) {
+    throw new McpRuntimeError(
+      "CLOUD_TEMPORARILY_UNAVAILABLE",
+      "Synapsor Cloud is temporarily unavailable and this Runner is configured not to queue proposals.",
+      { retry_after_ms: 1e3, cause_code: safeRuntimeErrorCode(error) }
+    );
+  }
+  if (result.ok && result.authenticated) return;
+  const errorCode = nonEmptyString(result.details?.error) ?? nonEmptyString(result.details?.error_code);
+  if (result.status === 401) {
+    throw new McpRuntimeError("CLOUD_RUNNER_AUTHENTICATION_FAILED", "The reviewed Synapsor Cloud Runner credential is not authenticated.");
+  }
+  if (result.status === 403) {
+    throw new McpRuntimeError("CLOUD_RUNNER_AUTHORIZATION_FAILED", "The reviewed Synapsor Cloud Runner identity is not authorized for this source.");
+  }
+  if ([409, 412, 422].includes(result.status)) {
+    throw new McpRuntimeError("CLOUD_CONNECTION_CONFLICT", "The reviewed local Cloud connection no longer matches the active Cloud contract or source.", {
+      ...errorCode ? { cloud_error_code: errorCode } : {}
+    });
+  }
+  if (result.status === 429) {
+    throw new McpRuntimeError("CLOUD_RATE_LIMITED", "Synapsor Cloud is rate limiting proposal submissions.", { retry_after_ms: 1e3 });
+  }
+  throw new McpRuntimeError(
+    "CLOUD_TEMPORARILY_UNAVAILABLE",
+    "Synapsor Cloud is temporarily unavailable and this Runner is configured not to queue proposals.",
+    { retry_after_ms: 1e3, cloud_status: result.status, ...errorCode ? { cloud_error_code: errorCode } : {} }
+  );
+}
+function cloudSafeChangeSet(changeSet) {
+  const sanitized = JSON.parse(JSON.stringify(changeSet));
+  sanitized.evidence.items = [];
+  const principalScope3 = sanitized.guards.principal_scope;
+  if (principalScope3) {
+    stripCloudPrincipalColumn(sanitized, principalScope3.column);
+    sanitized.principal.id = principalScope3.value_fingerprint;
+    delete principalScope3.value;
+  }
+  return sanitized;
+}
+function stripCloudPrincipalColumn(changeSet, column) {
+  const strip = (value) => {
+    if (isRecord5(value)) delete value[column];
+  };
+  strip(changeSet.before);
+  strip(changeSet.after);
+  if ("frozen_set" in changeSet && isRecord5(changeSet.frozen_set) && Array.isArray(changeSet.frozen_set.members)) {
+    for (const member of changeSet.frozen_set.members) {
+      if (!isRecord5(member)) continue;
+      strip(member.before);
+      strip(member.after);
+    }
+  }
+  if (changeSet.schema_version === protocolVersions.compensationChangeSet) {
+    for (const member of changeSet.compensation.descriptor.members) {
+      strip(member.expected_state);
+      strip(member.restore_values);
+    }
+  }
+}
+var CloudLinkedSynchronizer = class {
+  constructor(config, store, env = process.env) {
+    this.config = config;
+    this.store = store;
+    this.connection = loadCloudLinkedConnection(config, env);
+    this.client = new ControlPlaneClient({ baseUrl: this.connection.base_url, runnerToken: this.connection.runner_token, sourceId: this.connection.source_id, runnerId: this.connection.runner_id });
+    this.owner = `${this.connection.runner_id}:${process.pid}:${crypto5.randomBytes(4).toString("hex")}`;
+    if (!store.claimCloudOutbox || !store.acknowledgeCloudOutbox || !store.failCloudOutbox || !store.listCloudOutbox) {
+      throw new McpRuntimeError("CLOUD_OUTBOX_UNAVAILABLE", "Cloud-linked governance requires durable outbox support in the runtime store.");
+    }
+  }
+  config;
+  store;
+  connection;
+  client;
+  owner;
+  timer;
+  stopped = false;
+  activeDrain;
+  lastReconciledAt;
+  lastReconciliationErrorCode;
+  lastCompactedAt;
+  lastCompactedCount = 0;
+  start() {
+    if (this.timer || this.stopped) return;
+    const tick = async () => {
+      if (this.stopped) return;
+      await this.drainOnce().catch(() => void 0);
+      if (!this.stopped) {
+        this.timer = setTimeout(tick, this.config.governance?.sync_interval_ms ?? 2e3);
+        this.timer.unref?.();
+      }
+    };
+    void tick();
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.timer) clearTimeout(this.timer);
+    await this.activeDrain?.catch(() => void 0);
+  }
+  async drainOnce() {
+    if (this.activeDrain) return this.activeDrain;
+    const drain = this.performDrainOnce();
+    this.activeDrain = drain;
+    try {
+      return await drain;
+    } finally {
+      if (this.activeDrain === drain) this.activeDrain = void 0;
+    }
+  }
+  async synchronizeBeforeProposal() {
+    while (this.activeDrain) await this.activeDrain;
+    await this.drainOnce();
+  }
+  async flushEvent(eventId, timeoutMs = 3e4) {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    while (true) {
+      const current = (await this.store.listCloudOutbox({ limit: 1e4 })).find((item) => item.event_id === eventId);
+      if (!current) throw new McpRuntimeError("CLOUD_OUTBOX_EVENT_NOT_FOUND", `Cloud outbox event ${eventId} was not found.`);
+      if (current.status === "acknowledged") return current;
+      if (current.status === "dead_letter" || current.status === "reconciliation_required") {
+        throw new McpRuntimeError(
+          current.last_error_code ?? "CLOUD_OUTBOX_DELIVERY_FAILED",
+          `Cloud outbox event ${eventId} requires operator attention (${current.status}).`
+        );
+      }
+      await this.drainOnce();
+      const refreshed = (await this.store.listCloudOutbox({ limit: 1e4 })).find((item) => item.event_id === eventId);
+      if (!refreshed) throw new McpRuntimeError("CLOUD_OUTBOX_EVENT_NOT_FOUND", `Cloud outbox event ${eventId} was not found.`);
+      if (refreshed.status === "acknowledged") return refreshed;
+      if (refreshed.status === "dead_letter" || refreshed.status === "reconciliation_required") {
+        throw new McpRuntimeError(
+          refreshed.last_error_code ?? "CLOUD_OUTBOX_DELIVERY_FAILED",
+          `Cloud outbox event ${eventId} requires operator attention (${refreshed.status}).`
+        );
+      }
+      if (Date.now() >= deadline) return refreshed;
+      await new Promise((resolve2) => setTimeout(resolve2, Math.min(250, Math.max(1, deadline - Date.now()))));
+    }
+  }
+  async performDrainOnce() {
+    let acknowledged = 0;
+    let failed = 0;
+    const items = await this.store.claimCloudOutbox({ owner: this.owner, limit: 10, lease_ms: 3e4 });
+    for (const item of items) {
+      try {
+        const response = await this.deliver(item);
+        if (item.proposal_id && item.kind === "proposal") {
+          const cloudProposalId = nonEmptyString(response.proposal_id) ?? nonEmptyString(response.id) ?? item.proposal_id;
+          const requestId = nonEmptyString(response.request_id);
+          await this.store.recordCloudGovernanceEvent?.({
+            event_id: `cloud-governance:ack:${item.event_id}`,
+            proposal_id: item.proposal_id,
+            cloud_proposal_id: cloudProposalId,
+            kind: "proposal.cloud_acknowledged",
+            state: nonEmptyString(response.status) ?? "pending_review",
+            payload: { ...requestId ? { request_id: requestId } : {}, evidence_residency: "metadata_only", payload_hash: item.payload_hash }
+          });
+        }
+        await this.store.acknowledgeCloudOutbox(item.event_id, this.owner);
+        acknowledged += 1;
+      } catch (error) {
+        failed += 1;
+        const classification = classifyCloudSyncFailure(error);
+        await this.store.failCloudOutbox({ event_id: item.event_id, owner: this.owner, ...classification });
+      }
+    }
+    await this.reconcileOnce().catch((error) => {
+      this.lastReconciliationErrorCode = classifyCloudSyncFailure(error).error_code;
+    });
+    await this.compactAcknowledged().catch(() => void 0);
+    return { claimed: items.length, acknowledged, failed };
+  }
+  async status() {
+    const items = await this.store.listCloudOutbox({ limit: 1e4 });
+    const count = (status) => items.filter((item) => item.status === status).length;
+    const pending = items.filter((item) => item.status === "pending");
+    const acknowledged = items.filter((item) => item.status === "acknowledged" && item.acknowledged_at);
+    return {
+      authority_mode: "cloud_linked",
+      evidence_residency: "metadata_only",
+      pending: count("pending"),
+      leased: count("leased"),
+      acknowledged: count("acknowledged"),
+      dead_letter: count("dead_letter"),
+      reconciliation_required: count("reconciliation_required"),
+      ...pending[0] ? { oldest_pending_at: pending[0].created_at } : {},
+      ...acknowledged.length ? { last_acknowledged_at: acknowledged.map((item) => item.acknowledged_at).sort().at(-1) } : {},
+      ...this.lastReconciledAt ? { last_reconciled_at: this.lastReconciledAt } : {},
+      ...this.lastReconciliationErrorCode ? { last_reconciliation_error_code: this.lastReconciliationErrorCode } : {},
+      ...this.lastCompactedAt ? { last_compacted_at: this.lastCompactedAt, last_compacted_count: this.lastCompactedCount } : {}
+    };
+  }
+  async compactAcknowledged() {
+    if (!this.store.compactCloudOutbox) return;
+    const now = Date.now();
+    if (this.lastCompactedAt && now - Date.parse(this.lastCompactedAt) < 60 * 60 * 1e3) return;
+    const retentionDays = this.config.governance?.outbox_retention_days ?? 30;
+    const cutoff = new Date(now - retentionDays * 24 * 60 * 60 * 1e3).toISOString();
+    this.lastCompactedCount = await this.store.compactCloudOutbox({ acknowledged_before: cutoff });
+    this.lastCompactedAt = new Date(now).toISOString();
+  }
+  async reconcileOnce() {
+    if (!this.store.listCloudGovernanceEvents || !this.store.recordCloudGovernanceEvent) return { inspected: 0, recorded: 0 };
+    const acknowledged = (await this.store.listCloudOutbox({ status: "acknowledged", limit: 1e4 })).filter((item) => item.kind === "proposal" && item.proposal_id);
+    let recorded = 0;
+    for (const item of acknowledged.slice(-100)) {
+      const proposalId = item.proposal_id;
+      const events2 = await this.store.listCloudGovernanceEvents(proposalId);
+      const latest = events2.at(-1);
+      if (latest && ["applied", "failed", "conflict", "indeterminate", "canceled", "rejected"].includes(latest.state)) continue;
+      const response = await this.client.proposalStatus(proposalId);
+      const state = nonEmptyString(response.status) ?? "unknown";
+      const payload = cloudGovernanceStatusPayload(response);
+      const identity = canonicalJsonDigest({ proposal_id: proposalId, state, payload });
+      const eventId = `cloud-governance:state:${proposalId}:${identity.slice("sha256:".length, "sha256:".length + 20)}`;
+      const existed = events2.some((event) => event.event_id === eventId);
+      await this.store.recordCloudGovernanceEvent({
+        event_id: eventId,
+        proposal_id: proposalId,
+        cloud_proposal_id: nonEmptyString(response.proposal_id) ?? proposalId,
+        kind: `proposal.cloud_${state}`,
+        state,
+        payload
+      });
+      if (!existed) recorded += 1;
+    }
+    this.lastReconciledAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.lastReconciliationErrorCode = void 0;
+    return { inspected: acknowledged.length, recorded };
+  }
+  async deliver(item) {
+    if (item.kind === "proposal") return this.client.submitProposal(item.payload);
+    if (item.kind === "activity") return this.client.submitActivity(item.payload);
+    if (item.kind === "result") {
+      const result = isRecord5(item.payload.result) ? item.payload.result : void 0;
+      const leaseId = nonEmptyString(item.payload.lease_id);
+      if (!result || !leaseId) throw new McpRuntimeError("CLOUD_RESULT_OUTBOX_INVALID", "Cloud result outbox entry is missing a result or lease identity.");
+      return this.client.result(result, leaseId);
+    }
+    throw new McpRuntimeError("CLOUD_OUTBOX_KIND_UNSUPPORTED", `Unsupported Cloud outbox kind: ${item.kind}`);
+  }
+};
+function cloudGovernanceStatusPayload(response) {
+  const decision = isRecord5(response.decision) ? response.decision : void 0;
+  const job = isRecord5(response.job) ? response.job : void 0;
+  const result = isRecord5(response.result) ? response.result : void 0;
+  const actor = nonEmptyString(decision?.actor);
+  return JSON.parse(JSON.stringify({
+    contract_id: nonEmptyString(response.contract_id),
+    contract_version_id: nonEmptyString(response.contract_version_id),
+    contract_digest: nonEmptyString(response.contract_digest),
+    source_id: nonEmptyString(response.source_id),
+    terminal: response.terminal === true,
+    evidence_residency: "metadata_only",
+    decision: decision ? {
+      status: nonEmptyString(decision.status),
+      authority: "synapsor_cloud",
+      actor_fingerprint: actor ? canonicalJsonDigest({ actor }) : void 0,
+      decided_at: nonEmptyString(decision.decided_at)
+    } : void 0,
+    job: job ? {
+      job_id: nonEmptyString(job.job_id),
+      status: nonEmptyString(job.status),
+      attempt_count: typeof job.attempt_count === "number" ? job.attempt_count : void 0,
+      leased_runner_id: nonEmptyString(job.leased_runner_id),
+      lease_expires_at: job.lease_expires_at
+    } : void 0,
+    result: result ? {
+      status: nonEmptyString(result.status),
+      source_database_mutated: result.source_database_mutated === true,
+      affected_rows: typeof result.affected_rows === "number" ? result.affected_rows : void 0,
+      receipt_id: nonEmptyString(result.receipt_id),
+      result_hash: nonEmptyString(result.result_hash),
+      error_code: nonEmptyString(result.error_code)
+    } : void 0,
+    updated_at: response.updated_at
+  }));
+}
+function classifyCloudSyncFailure(error) {
+  if (error instanceof CloudControlError) {
+    const reconciliation = [409, 412, 422].includes(error.status) || ["contract_digest_mismatch", "proposal_hash_mismatch", "cloud_state_conflict"].includes(error.error_code);
+    return {
+      error_code: error.error_code,
+      retryable: error.retryable && !reconciliation,
+      ...error.retry_after_ms === void 0 ? {} : { retry_after_ms: error.retry_after_ms },
+      ...reconciliation ? { reconciliation: true } : {}
+    };
+  }
+  if (error instanceof McpRuntimeError) return { error_code: error.code, retryable: false };
+  return { error_code: "cloud_sync_internal", retryable: false };
+}
+function nonEmptyString(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim();
+  return normalized || void 0;
+}
 function rememberCapabilityName(seen, name, origin) {
   const previous = seen.get(name);
   if (previous) {
@@ -32848,6 +34257,8 @@ function runtimeContextFromSpec(context) {
   const provider = context.bindings.some((binding) => binding.source === "environment") ? "environment" : context.bindings.some((binding) => binding.source === "cloud_session") ? "cloud_session" : context.bindings.some((binding) => binding.source === "http_claim") ? "http_claims" : context.bindings.some((binding) => binding.source === "static_dev") ? "static_dev" : "environment";
   return {
     provider,
+    tenant_binding: context.tenant_binding,
+    principal_binding: context.principal_binding,
     values: {
       ...tenantBinding ? { tenant_id_env: tenantBinding.key, tenant_id_key: tenantBinding.key } : {},
       ...principalBinding ? { principal_env: principalBinding.key, principal_key: principalBinding.key } : {}
@@ -32862,6 +34273,7 @@ function runtimeCapabilityFromSpec(capability, resources, config, provenance) {
     table: subjectResource?.table ?? capability.subject.table ?? "",
     primary_key: subjectResource?.primary_key ?? capability.subject.primary_key ?? "",
     tenant_key: subjectResource?.tenant_key ?? capability.subject.tenant_key,
+    principal_scope_key: capability.subject.principal_scope_key,
     single_tenant_dev: subjectResource?.single_tenant_dev ?? capability.subject.single_tenant_dev
   };
   const runtime = {
@@ -32920,6 +34332,9 @@ function createMcpRuntime(config, options = {}) {
   const cloudTools = options.cloudTools ?? [];
   const resultFormat = options.resultFormat ?? config.result_format ?? 1;
   const trustedContext = options.trustedContext;
+  if (config.governance?.mode === "cloud_linked") loadCloudLinkedConnection(config, env);
+  const cloudSynchronizer = ownsStore && config.governance?.mode === "cloud_linked" ? new CloudLinkedSynchronizer(config, store, env) : void 0;
+  cloudSynchronizer?.start();
   const assertLocalStoreAvailable = ownsStore && sharedPostgres?.mode !== "runtime_store";
   const assertStoreAvailable = () => {
     if (assertLocalStoreAvailable) assertPersistentStoreAvailable(storePath);
@@ -32931,6 +34346,7 @@ function createMcpRuntime(config, options = {}) {
     callTool: async (name, args) => {
       const capability = config.mode === "cloud" ? void 0 : localCapabilities(config).find((item) => item.name === name);
       try {
+        if (capability?.kind === "proposal") await cloudSynchronizer?.synchronizeBeforeProposal();
         if (capability) {
           const context = resolveTrustedContext(config, env, capability, trustedContext);
           await resources.consumeRateLimit(context, capability.name);
@@ -32953,7 +34369,9 @@ function createMcpRuntime(config, options = {}) {
     },
     poolMetrics: () => resources.poolMetrics(),
     rateLimitMetrics: () => resources.rateLimitMetrics(),
+    cloudSyncStatus: async () => cloudSynchronizer ? cloudSynchronizer.status() : { authority_mode: "local_only", evidence_residency: "metadata_only", pending: 0, leased: 0, acknowledged: 0, dead_letter: 0, reconciliation_required: 0 },
     close: async () => {
+      await cloudSynchronizer?.stop();
       if (ownsResources) await resources.close();
       if (!options.store) await store.close();
     }
@@ -33232,6 +34650,8 @@ async function startStreamableHttpMcpServer(options = {}) {
   const cloudTools = config.mode === "cloud" ? await fetchCloudToolMetadata(config, env) : void 0;
   const sharedStorePath = options.storePath ?? config.storage?.sqlite_path ?? "./.synapsor/local.db";
   const sharedStore = createDefaultRuntimeStore(config, env, sharedStorePath);
+  const cloudSynchronizer = config.governance?.mode === "cloud_linked" ? new CloudLinkedSynchronizer(config, sharedStore, env) : void 0;
+  cloudSynchronizer?.start();
   const sharedResources = createMcpRuntimeSharedResources(config, env, options.readRow);
   const sessions = /* @__PURE__ */ new Map();
   const openSessions = /* @__PURE__ */ new Set();
@@ -33274,6 +34694,7 @@ async function startStreamableHttpMcpServer(options = {}) {
       });
     });
   } catch (error) {
+    await cloudSynchronizer?.stop();
     await closeStreamableSessions(openSessions);
     await sharedResources.close();
     await sharedStore.close();
@@ -33301,7 +34722,7 @@ async function startStreamableHttpMcpServer(options = {}) {
     host: actualHost,
     port: actualPort,
     url,
-    close: () => closeStreamableHttpServer(server, openSessions, sharedResources, sharedStore)
+    close: () => closeStreamableHttpServer(server, openSessions, sharedResources, sharedStore, cloudSynchronizer)
   };
 }
 async function handleStreamableHttpMcpRequest(input) {
@@ -33876,13 +35297,14 @@ async function closeHttpServer(server, runtime) {
     });
   }).finally(() => runtime.close());
 }
-async function closeStreamableHttpServer(server, sessions, sharedResources, sharedStore) {
+async function closeStreamableHttpServer(server, sessions, sharedResources, sharedStore, cloudSynchronizer) {
   await new Promise((resolve2, reject) => {
     server.close((error) => {
       if (error) reject(error);
       else resolve2();
     });
   }).finally(async () => {
+    await cloudSynchronizer?.stop();
     await closeStreamableSessions(sessions);
     await sharedResources.close();
     await sharedStore.close();
@@ -34015,6 +35437,9 @@ async function callConfiguredTool(input) {
     assertProposalWritebackResolvable(input.config, capability);
     assertApprovalPolicyResolvable(input.config, capability);
   }
+  if (capability.kind === "proposal") {
+    await assertCloudLinkedProposalAvailability(input.config, input.env);
+  }
   const source = input.config.sources?.[capability.source];
   if (!source) throw new McpRuntimeError("SOURCE_NOT_FOUND", `Unknown source: ${capability.source}`);
   const context = resolveTrustedContext(input.config, input.env, capability, input.trustedContext);
@@ -34045,6 +35470,8 @@ async function callConfiguredTool(input) {
   const patch = capability.kind !== "proposal" || operation === "delete" || batchInsert ? {} : buildPatch(capability, input.args);
   const itemPatches = batchInsert ? batchItems.map((item) => buildItemPatch(capability, item, input.args)) : [];
   const before = scalarRecord(current.row);
+  const principalScope3 = effectivePrincipalScope(input.config, capability, context);
+  const principalScopeMetadata = principalScope3 ? withoutPrincipalScopeValue(principalScope3) : void 0;
   if (capability.kind === "proposal") {
     if (setOperation && !batchInsert) currentRows.forEach((row) => enforcePatchGuards(capability, scalarRecord(row), patch));
     else if (batchInsert) itemPatches.forEach((itemPatch) => enforcePatchGuards(capability, {}, itemPatch));
@@ -34055,12 +35482,14 @@ async function callConfiguredTool(input) {
     action: capability.name,
     operation,
     tenant: context.tenant_id,
+    principal_scope: principalScope3?.value_fingerprint,
     before: setOperation ? currentRows.map(scalarRecord) : before,
     patch: batchInsert ? itemPatches : patch,
     created_at: createdAt
   } : {
     action: capability.name,
     tenant: context.tenant_id,
+    principal_scope: principalScope3?.value_fingerprint,
     object: String(current.row[capability.target.primary_key] ?? input.args[capability.lookup.id_from_arg]),
     before,
     patch,
@@ -34071,12 +35500,14 @@ async function callConfiguredTool(input) {
   const objectId = setOperation ? stableId("set", {
     capability: capability.name,
     tenant: context.tenant_id,
+    principal_scope: principalScope3?.value_fingerprint,
     identities: batchInsert ? batchItems : currentRows.map((row) => row[capability.target.primary_key])
   }) : capability.kind === "proposal" && operation === "insert" ? String(primaryDedup?.value ?? proposalId) : String(current.row[capability.target.primary_key] ?? input.args[capability.lookup.id_from_arg]);
   const evidenceBundleId = stableId("ev", {
     capability: capability.name,
     source: capability.source,
     tenant: context.tenant_id,
+    principal_scope: principalScope3?.value_fingerprint,
     row: capability.kind === "proposal" && operation === "insert" ? void 0 : setOperation ? currentRows : current.row,
     patch: capability.kind === "proposal" && operation === "insert" ? batchInsert ? itemPatches : patch : void 0,
     at: createdAt
@@ -34111,7 +35542,8 @@ async function callConfiguredTool(input) {
       principal: context.principal,
       tenant_id: context.tenant_id,
       source_database_changed: false,
-      binding_provenance: context.provenance
+      binding_provenance: context.provenance,
+      ...principalScopeMetadata ? { principal_scope: principalScopeMetadata } : {}
     },
     items: setOperation ? boundedSetEvidenceItems(capability, context, operation, currentRows, itemPatches, batchItems) : [{
       kind: capability.kind === "proposal" && operation === "insert" ? "reviewed_insert_intent" : "external_row",
@@ -34119,7 +35551,8 @@ async function callConfiguredTool(input) {
       table: `${capability.target.schema}.${capability.target.table}`,
       primary_key: { column: capability.target.primary_key, value: objectId },
       tenant: capability.target.tenant_key ? { column: capability.target.tenant_key, value: context.tenant_id } : void 0,
-      visible_row: capability.kind === "proposal" && operation === "insert" ? patch : scalarRecord(current.row),
+      ...principalScopeMetadata ? { principal_scope: principalScopeMetadata } : {},
+      visible_row: capability.kind === "proposal" && operation === "insert" ? patch : visibleScalarRecord(capability, current.row),
       ...resolvedDeduplication ? { deduplication: resolvedDeduplication } : {}
     }]
   });
@@ -34134,6 +35567,8 @@ async function callConfiguredTool(input) {
         capability: capability.name,
         columns: capability.visible_columns,
         tenant_bound: Boolean(capability.target.tenant_key),
+        principal_bound: Boolean(principalScope3),
+        ...principalScopeMetadata ? { principal_scope: principalScopeMetadata } : {},
         statement_template: selectTemplate(capability),
         parameters_redacted: true
       }
@@ -34148,7 +35583,7 @@ async function callConfiguredTool(input) {
         type: capability.target.table,
         id: objectId
       },
-      data: scalarRecord(current.row),
+      data: visibleScalarRecord(capability, current.row),
       trusted_context: {
         tenant_id: context.tenant_id,
         principal: context.principal,
@@ -34183,7 +35618,7 @@ async function callConfiguredTool(input) {
     }
     throw error;
   }
-  const approvalResult = await maybeAutoApproveProposal({
+  const approvalResult = input.config.governance?.mode === "cloud_linked" ? { proposal, approved: false } : await maybeAutoApproveProposal({
     config: input.config,
     capability,
     store: input.store,
@@ -34198,7 +35633,8 @@ async function callConfiguredTool(input) {
       capability: capability.name,
       proposal_id: proposal.proposal_id,
       source_database_changed: false,
-      approval_status: approvalResult.proposal.state === "approved" ? "approved" : changeSet.approval.status
+      approval_status: approvalResult.proposal.state === "approved" ? "approved" : changeSet.approval.status,
+      ...principalScopeMetadata ? { principal_scope: principalScopeMetadata } : {}
     },
     items: [
       {
@@ -34220,12 +35656,22 @@ async function callConfiguredTool(input) {
       payload: {
         capability: capability.name,
         statement_template: selectTemplate(capability),
-        parameters_redacted: true
+        parameters_redacted: true,
+        principal_bound: Boolean(principalScope3),
+        ...principalScopeMetadata ? { principal_scope: principalScopeMetadata } : {}
       }
     });
   }
+  await enqueueCloudLinkedProposal({
+    config: input.config,
+    store: input.store,
+    proposal: approvalResult.proposal,
+    evidenceBundleId,
+    queryFingerprint,
+    env: input.env
+  });
   return {
-    status: input.config.mode === "shadow" ? "shadow_proposal_created" : 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.proposal.state === "approved" ? "approved" : "review_required",
     action: capability.name,
     proposal_id: approvalResult.proposal.proposal_id,
     proposal_version: approvalResult.proposal.proposal_version,
@@ -34250,6 +35696,7 @@ async function callConfiguredTool(input) {
       } : {}
     },
     approval_required: approvalResult.proposal.state === "pending_review",
+    governance: input.config.governance?.mode === "cloud_linked" ? { authority: "synapsor_cloud", state: "pending_cloud_sync", evidence_residency: "metadata_only" } : { authority: "local" },
     writeback: changeSet.writeback,
     source_database_changed: false,
     source_database_mutated: false
@@ -34264,7 +35711,12 @@ async function recordAggregateRead(input) {
   const suppressed = groupSize < aggregate.minimum_group_size;
   const value = suppressed ? null : finiteAggregateNumber(input.current.row.aggregate_value, "AGGREGATE_VALUE_INVALID");
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  const evidenceBundleId = stableId("ev", { capability: input.capability.name, tenant: input.context.tenant_id, aggregate, suppressed, value, at: createdAt });
+  const aggregatePrincipalScope = input.capability.target.principal_scope_key ? {
+    schema_version: protocolVersions.principalScope,
+    column: input.capability.target.principal_scope_key,
+    value_fingerprint: canonicalJsonDigest({ principal: input.context.principal })
+  } : void 0;
+  const evidenceBundleId = stableId("ev", { capability: input.capability.name, tenant: input.context.tenant_id, principal_scope: aggregatePrincipalScope?.value_fingerprint, aggregate, suppressed, value, at: createdAt });
   const queryFingerprint = queryFingerprintFor(input.capability, input.context);
   await input.store.recordEvidenceBundle({
     evidence_bundle_id: evidenceBundleId,
@@ -34282,6 +35734,7 @@ async function recordAggregateRead(input) {
       principal: input.context.principal,
       tenant_id: input.context.tenant_id,
       binding_provenance: input.context.provenance,
+      ...aggregatePrincipalScope ? { principal_scope: aggregatePrincipalScope } : {},
       aggregate: aggregate.function,
       aggregate_column: aggregate.column ?? null,
       count_mode: aggregate.count_mode ?? null,
@@ -34313,6 +35766,8 @@ async function recordAggregateRead(input) {
       count_mode: aggregate.count_mode ?? null,
       fixed_selection: aggregate.selection ?? null,
       tenant_bound: Boolean(input.capability.target.tenant_key),
+      principal_bound: Boolean(aggregatePrincipalScope),
+      ...aggregatePrincipalScope ? { principal_scope: aggregatePrincipalScope } : {},
       minimum_group_size: aggregate.minimum_group_size,
       suppressed,
       source_member_count_recorded: false,
@@ -34573,6 +36028,16 @@ function safeToolError(error) {
     const retryAfter = error instanceof McpRuntimeError && typeof error.details?.retry_after_ms === "number" ? Math.max(1, Math.round(error.details.retry_after_ms)) : void 0;
     return { code: "RATE_LIMITED", message: "The trusted tenant request limit was reached. Retry after the current window.", retryable: true, ...retryAfter ? { retry_after_ms: retryAfter } : {} };
   }
+  if (runtimeCode === "CLOUD_RATE_LIMITED") {
+    const retryAfter = error instanceof McpRuntimeError && typeof error.details?.retry_after_ms === "number" ? Math.max(1, Math.round(error.details.retry_after_ms)) : DEFAULT_INFRA_RETRY_AFTER_MS;
+    return { code: "RATE_LIMITED", message: "Synapsor Cloud is rate limiting proposal submissions. Retry after the current window.", retryable: true, retry_after_ms: retryAfter };
+  }
+  if (runtimeCode === "CLOUD_TEMPORARILY_UNAVAILABLE") {
+    return temporarilyUnavailableError("Synapsor Cloud is temporarily unavailable. Retry later or enable reviewed durable proposal queueing.", error);
+  }
+  if (runtimeCode && ["CLOUD_RUNNER_AUTHENTICATION_FAILED", "CLOUD_RUNNER_AUTHORIZATION_FAILED", "CLOUD_CONNECTION_CONFLICT"].includes(runtimeCode)) {
+    return { code: "POLICY_VIOLATION", message: "The reviewed Synapsor Cloud authority rejected this Runner connection.", retryable: false };
+  }
   if (runtimeCode && (runtimeCode.startsWith("ARGUMENT_") || runtimeCode === "LOOKUP_ARG_MISSING" || runtimeCode === "MODEL_PREDICATE_REJECTED" || runtimeCode === "MODEL_CANNOT_OVERRIDE_BINDING" || runtimeCode === "TRUSTED_BINDING_MISSING" || runtimeCode === "TRUSTED_CONTEXT_MISSING")) {
     return { code: "INVALID_ARGUMENT", message: "The tool input or trusted context binding is invalid.", retryable: false };
   }
@@ -34733,9 +36198,24 @@ function errorMessage(error) {
   if (isRecord5(error) && typeof error.message === "string") return error.message;
   return typeof error === "string" ? error : "";
 }
+function effectivePrincipalScope(config, capability, context) {
+  const column = capability.target.principal_scope_key;
+  if (!column) return void 0;
+  const contextConfig = (capability.context ? config.contexts?.[capability.context] : void 0) ?? config.trusted_context;
+  if (!contextConfig) throw new McpRuntimeError("TRUSTED_CONTEXT_MISSING", `Principal-scoped capability ${capability.name} has no trusted context.`);
+  const binding = contextConfig.principal_binding ?? "principal";
+  const value = scalar3(context.principal);
+  const material = { column, binding, provider: contextConfig.provider, value };
+  return {
+    schema_version: protocolVersions.principalScope,
+    ...material,
+    value_fingerprint: principalScopeFingerprint(material)
+  };
+}
 function buildChangeSet(input) {
   const patch = input.patch;
   const before = scalarRecord(input.currentRow);
+  const principalScope3 = effectivePrincipalScope(input.config, input.capability, input.context);
   if (isSetCapability(input.capability)) return buildBoundedSetChangeSet(input);
   enforcePatchGuards(input.capability, before, patch);
   const operation = input.capability.operation?.kind ?? "update";
@@ -34749,6 +36229,7 @@ function buildChangeSet(input) {
   if (operation === "insert" && input.resolvedDeduplication) {
     for (const component of input.resolvedDeduplication.components) after[component.column] = component.value;
   }
+  if (operation === "insert" && principalScope3) after[principalScope3.column] = principalScope3.value;
   const writebackMode = capabilityWritebackMode2(input.capability);
   const changeSetWritebackMode = writebackMode === "none" ? "read_only" : "trusted_worker_required";
   const writebackExecutor = writebackMode === "none" ? "none" : writebackMode === "cloud_worker" ? "cloud_worker" : writebackMode === "direct_sql" ? "sql_update" : capabilityWritebackExecutor(input.capability);
@@ -34789,6 +36270,7 @@ function buildChangeSet(input) {
       after,
       guards: {
         tenant: { column: input.capability.target.tenant_key ?? "__single_tenant_dev", value: input.capability.target.tenant_key ? input.context.tenant_id : "single_tenant_dev" },
+        ...principalScope3 ? { principal_scope: principalScope3 } : {},
         allowed_columns: input.capability.allowed_columns ?? Object.keys(patch),
         ...guard ? { expected_version: guard } : {},
         ...input.capability.operation.version_advance ? { version_advance: input.capability.operation.version_advance } : {},
@@ -34855,6 +36337,7 @@ function buildChangeSet(input) {
     after,
     guards: {
       tenant: { column: input.capability.target.tenant_key ?? "__single_tenant_dev", value: input.capability.target.tenant_key ? input.context.tenant_id : "single_tenant_dev" },
+      ...principalScope3 ? { principal_scope: principalScope3 } : {},
       allowed_columns: input.capability.allowed_columns ?? Object.keys(patch),
       expected_version: guard
     },
@@ -34884,6 +36367,7 @@ function buildChangeSet(input) {
   };
 }
 function buildBoundedSetChangeSet(input) {
+  const principalScope3 = effectivePrincipalScope(input.config, input.capability, input.context);
   const operation = input.capability.operation;
   if (!operation || operation.cardinality !== "set" || !operation.max_rows || !operation.aggregate_bounds?.length) {
     throw new McpRuntimeError("SET_GUARDS_REQUIRED", `Bounded set capability ${input.capability.name} is missing reviewed set guards.`);
@@ -34901,6 +36385,7 @@ function buildBoundedSetChangeSet(input) {
       if (Object.prototype.hasOwnProperty.call(after, component.column)) throw new McpRuntimeError("BATCH_DEDUP_COLUMN_COLLISION", `Batch deduplication column ${component.column} collides with a patch column.`);
       after[component.column] = component.value;
     }
+    if (principalScope3) after[principalScope3.column] = principalScope3.value;
     return {
       primary_key: { column: input.capability.target.primary_key, value: primary.value },
       before: {},
@@ -34985,6 +36470,7 @@ function buildBoundedSetChangeSet(input) {
     after: { row_count: kind === "set_delete" ? 0 : members.length },
     guards: {
       tenant: { column: input.capability.target.tenant_key ?? "__single_tenant_dev", value: input.capability.target.tenant_key ? input.context.tenant_id : "single_tenant_dev" },
+      ...principalScope3 ? { principal_scope: principalScope3 } : {},
       allowed_columns: kind === "set_delete" ? [] : input.capability.allowed_columns ?? Object.keys(input.patch),
       ...kind === "set_update" && operation.version_advance ? { version_advance: operation.version_advance } : {}
     },
@@ -35257,6 +36743,7 @@ function buildSelect(capability, placeholderStyle) {
     const fixedTerms = aggregate.selection?.all ?? [];
     const where2 = fixedTerms.map((term, index) => `${quoteIdentifier(term.column, placeholderStyle)} = ${placeholderStyle === "$" ? `$${index + 1}` : "?"}`);
     if (capability.target.tenant_key) where2.push(`${quoteIdentifier(capability.target.tenant_key, placeholderStyle)} = ${placeholderStyle === "$" ? `$${fixedTerms.length + 1}` : "?"}`);
+    if (capability.target.principal_scope_key) where2.push(`${quoteIdentifier(capability.target.principal_scope_key, placeholderStyle)} = ${placeholderStyle === "$" ? `$${fixedTerms.length + 2}` : "?"}`);
     const expression = aggregate.function === "count" && aggregate.count_mode === "rows" ? "COUNT(*)" : `${aggregate.function.toUpperCase()}(${quoteIdentifier(aggregate.column ?? "", placeholderStyle)})`;
     return { sql: `SELECT ${expression} AS aggregate_value, COUNT(*) AS group_size FROM ${quoteIdentifier(capability.target.schema, placeholderStyle)}.${quoteIdentifier(capability.target.table, placeholderStyle)}${where2.length ? ` WHERE ${where2.join(" AND ")}` : ""}` };
   }
@@ -35268,45 +36755,60 @@ function buildSelect(capability, placeholderStyle) {
       const tenantIndex = fixedTerms.length + 1;
       where2.push(`${quoteIdentifier(capability.target.tenant_key, placeholderStyle)} = ${placeholderStyle === "$" ? `$${tenantIndex}` : "?"}`);
     }
+    if (capability.target.principal_scope_key) {
+      const principalIndex = fixedTerms.length + 2;
+      where2.push(`${quoteIdentifier(capability.target.principal_scope_key, placeholderStyle)} = ${placeholderStyle === "$" ? `$${principalIndex}` : "?"}`);
+    }
     const maxRows = capability.operation?.max_rows ?? 0;
     return {
       sql: `SELECT ${columns} FROM ${quoteIdentifier(capability.target.schema, placeholderStyle)}.${quoteIdentifier(capability.target.table, placeholderStyle)} WHERE ${where2.join(" AND ")} ORDER BY ${quoteIdentifier(capability.target.primary_key, placeholderStyle)} ASC LIMIT ${maxRows + 1}`
     };
   }
-  const placeholders = placeholderStyle === "$" ? ["$1", "$2"] : ["?", "?"];
+  const placeholders = placeholderStyle === "$" ? ["$1", "$2", "$3"] : ["?", "?", "?"];
   const where = [
     `${quoteIdentifier(capability.target.primary_key, placeholderStyle)} = ${placeholders[0]}`
   ];
   if (capability.target.tenant_key) {
     where.push(`${quoteIdentifier(capability.target.tenant_key, placeholderStyle)} = ${placeholders[1]}`);
   }
+  if (capability.target.principal_scope_key) {
+    where.push(`${quoteIdentifier(capability.target.principal_scope_key, placeholderStyle)} = ${placeholders[2]}`);
+  }
   const sql = `SELECT ${columns} FROM ${quoteIdentifier(capability.target.schema, placeholderStyle)}.${quoteIdentifier(capability.target.table, placeholderStyle)} WHERE ${where.join(" AND ")} LIMIT ${Math.max(1, capability.max_rows ?? 1)}`;
   return { sql };
 }
 function queryValues(capability, args, context) {
   if (capability.kind === "aggregate_read") return [
     ...(capability.aggregate?.selection?.all ?? []).map((term) => term.value),
-    ...capability.target.tenant_key ? [context.tenant_id] : []
+    ...capability.target.tenant_key ? [context.tenant_id] : [],
+    ...capability.target.principal_scope_key ? [context.principal] : []
   ];
   if (isSetSelectionCapability(capability)) {
     return [
       ...(capability.operation?.selection?.all ?? []).map((term) => term.value),
-      ...capability.target.tenant_key ? [context.tenant_id] : []
+      ...capability.target.tenant_key ? [context.tenant_id] : [],
+      ...capability.target.principal_scope_key ? [context.principal] : []
     ];
   }
   const pkValue = args[capability.lookup.id_from_arg];
   if (pkValue === void 0) throw new McpRuntimeError("LOOKUP_ARG_MISSING", `${capability.lookup.id_from_arg} is required.`);
-  return capability.target.tenant_key ? [pkValue, context.tenant_id] : [pkValue];
+  return [
+    pkValue,
+    ...capability.target.tenant_key ? [context.tenant_id] : [],
+    ...capability.target.principal_scope_key ? [context.principal] : []
+  ];
 }
 function readColumns(capability) {
   if (capability.kind === "aggregate_read") return [
     ...capability.aggregate?.column ? [capability.aggregate.column] : [],
     ...(capability.aggregate?.selection?.all ?? []).map((term) => term.column),
-    ...capability.target.tenant_key ? [capability.target.tenant_key] : []
+    ...capability.target.tenant_key ? [capability.target.tenant_key] : [],
+    ...capability.target.principal_scope_key ? [capability.target.principal_scope_key] : []
   ];
   const columns = new Set(capability.visible_columns);
   columns.add(capability.target.primary_key);
   if (capability.target.tenant_key) columns.add(capability.target.tenant_key);
+  if (capability.target.principal_scope_key) columns.add(capability.target.principal_scope_key);
   if (capability.conflict_guard?.column) columns.add(capability.conflict_guard.column);
   for (const term of capability.operation?.selection?.all ?? []) columns.add(term.column);
   for (const bound of capability.operation?.aggregate_bounds ?? []) columns.add(bound.column);
@@ -35518,7 +37020,7 @@ function boundedSetEvidenceItems(capability, context, operation, currentRows, it
     table: `${capability.target.schema}.${capability.target.table}`,
     primary_key: { column: capability.target.primary_key, value: scalar3(row[capability.target.primary_key]) },
     tenant: capability.target.tenant_key ? { column: capability.target.tenant_key, value: context.tenant_id } : void 0,
-    visible_row: scalarRecord(row)
+    visible_row: visibleScalarRecord(capability, row)
   }));
 }
 function resolveDeduplication(capability, proposalId, context) {
@@ -35649,6 +37151,10 @@ async function resourceResult(uri, reader) {
   };
 }
 function queryFingerprintFor(capability, context) {
+  const principalScope3 = capability.target.principal_scope_key ? {
+    column: capability.target.principal_scope_key,
+    value_fingerprint: canonicalJsonDigest({ principal: context.principal })
+  } : void 0;
   return hashJson({
     source: capability.source,
     target: capability.target,
@@ -35657,28 +37163,42 @@ function queryFingerprintFor(capability, context) {
     aggregate: capability.aggregate,
     columns: readColumns(capability),
     tenant_bound: Boolean(capability.target.tenant_key),
-    tenant: context.tenant_id
+    tenant: context.tenant_id,
+    ...principalScope3 ? { principal_scope: principalScope3 } : {}
   });
 }
 function selectTemplate(capability) {
   if (capability.kind === "aggregate_read") {
     const aggregate = capability.aggregate;
     const expression = aggregate?.function === "count" && aggregate.count_mode === "rows" ? "COUNT(*)" : `${aggregate?.function?.toUpperCase() ?? "AGGREGATE"}(${aggregate?.column ?? "<fixed column>"})`;
-    const terms = (aggregate?.selection?.all ?? []).map((term) => `${term.column} = <fixed>`);
-    if (capability.target.tenant_key) terms.push(`${capability.target.tenant_key} = <trusted tenant>`);
-    return `SELECT ${expression}, COUNT(*) AS group_size FROM ${capability.target.schema}.${capability.target.table}${terms.length ? ` WHERE ${terms.join(" AND ")}` : ""}`;
+    const terms2 = (aggregate?.selection?.all ?? []).map((term) => `${term.column} = <fixed>`);
+    if (capability.target.tenant_key) terms2.push(`${capability.target.tenant_key} = <trusted tenant>`);
+    if (capability.target.principal_scope_key) terms2.push(`${capability.target.principal_scope_key} = <trusted principal>`);
+    return `SELECT ${expression}, COUNT(*) AS group_size FROM ${capability.target.schema}.${capability.target.table}${terms2.length ? ` WHERE ${terms2.join(" AND ")}` : ""}`;
   }
   if (isSetSelectionCapability(capability)) {
-    const terms = (capability.operation?.selection?.all ?? []).map((term) => `${term.column} = <fixed>`);
-    if (capability.target.tenant_key) terms.push(`${capability.target.tenant_key} = <trusted tenant>`);
-    return `SELECT ${readColumns(capability).join(", ")} FROM ${capability.target.schema}.${capability.target.table} WHERE ${terms.join(" AND ")} ORDER BY ${capability.target.primary_key} ASC LIMIT ${(capability.operation?.max_rows ?? 0) + 1}`;
-  }
-  const where = capability.target.tenant_key ? `${capability.target.primary_key} = ? AND ${capability.target.tenant_key} = ?` : `${capability.target.primary_key} = ?`;
+    const terms2 = (capability.operation?.selection?.all ?? []).map((term) => `${term.column} = <fixed>`);
+    if (capability.target.tenant_key) terms2.push(`${capability.target.tenant_key} = <trusted tenant>`);
+    if (capability.target.principal_scope_key) terms2.push(`${capability.target.principal_scope_key} = <trusted principal>`);
+    return `SELECT ${readColumns(capability).join(", ")} FROM ${capability.target.schema}.${capability.target.table} WHERE ${terms2.join(" AND ")} ORDER BY ${capability.target.primary_key} ASC LIMIT ${(capability.operation?.max_rows ?? 0) + 1}`;
+  }
+  const terms = [`${capability.target.primary_key} = ?`];
+  if (capability.target.tenant_key) terms.push(`${capability.target.tenant_key} = ?`);
+  if (capability.target.principal_scope_key) terms.push(`${capability.target.principal_scope_key} = ?`);
+  const where = terms.join(" AND ");
   return `SELECT ${readColumns(capability).join(", ")} FROM ${capability.target.schema}.${capability.target.table} WHERE ${where} LIMIT ${capability.max_rows ?? 1}`;
 }
 function scalarRecord(row) {
   return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, scalar3(value)]));
 }
+function visibleScalarRecord(capability, row) {
+  const visible = new Set(capability.visible_columns);
+  return Object.fromEntries(Object.entries(row).filter(([column]) => visible.has(column)).map(([key, value]) => [key, scalar3(value)]));
+}
+function withoutPrincipalScopeValue(scope) {
+  const { value: _value, ...metadata } = scope;
+  return metadata;
+}
 function scalar3(value) {
   if (value === null || value === void 0) return null;
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
@@ -35743,6 +37263,12 @@ function quoteMysqlIdentifier(identifier) {
 function operationOf2(job) {
   return job.operation ?? "single_row_update";
 }
+function principalScope2(job) {
+  const scope = job.target.principal_scope;
+  if (!scope) return void 0;
+  if (scope.value === void 0) throw new Error("PRINCIPAL_SCOPE_VALUE_REQUIRED");
+  return { column: scope.column, value: scope.value };
+}
 function receiptAuthority2(config) {
   return config.receipts?.authority ?? "source_db";
 }
@@ -35771,6 +37297,11 @@ function buildMysqlUpdate(job) {
     `${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`,
     `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`
   ];
+  const scope = principalScope2(job);
+  if (scope) {
+    values.push(scope.value);
+    where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+  }
   if (job.conflict_guard.kind === "version_column") {
     values.push(job.conflict_guard.expected_value);
     where.push(`${quoteMysqlIdentifier(job.conflict_guard.column)} = ?`);
@@ -35793,13 +37324,17 @@ VALUES (${columns.map(() => "?").join(", ")})`,
 function buildMysqlDelete(job) {
   if (operationOf2(job) !== "single_row_delete") throw new Error("mysql delete builder requires single_row_delete");
   if (job.target.primary_key.value === void 0 || job.conflict_guard.kind !== "version_column") throw new Error("mysql delete requires primary-key and exact version guards");
-  return {
-    sql: `DELETE FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ?
-  AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?
-  AND ${quoteMysqlIdentifier(job.conflict_guard.column)} = ?`,
-    values: [job.target.primary_key.value, job.target.tenant_guard.value, job.conflict_guard.expected_value]
-  };
+  const values = [job.target.primary_key.value, job.target.tenant_guard.value];
+  const where = [`${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`, `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+  const scope = principalScope2(job);
+  if (scope) {
+    values.push(scope.value);
+    where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+  }
+  values.push(job.conflict_guard.expected_value);
+  where.push(`${quoteMysqlIdentifier(job.conflict_guard.column)} = ?`);
+  return { sql: `DELETE FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
+WHERE ${where.join("\n  AND ")}`, values };
 }
 function validatePatch2(job, engine) {
   const patchColumns = Object.keys(job.patch || {});
@@ -35807,6 +37342,8 @@ function validatePatch2(job, engine) {
   const allowed = new Set(job.allowed_columns);
   if (allowed.has(job.target.primary_key.column)) throw new Error(`${engine} primary key column must not be patch-allowlisted`);
   if (allowed.has(job.target.tenant_guard.column)) throw new Error(`${engine} tenant guard column must not be patch-allowlisted`);
+  const scope = principalScope2(job);
+  if (scope && allowed.has(scope.column)) throw new Error(`${engine} principal scope column must not be patch-allowlisted`);
   for (const column of patchColumns) if (!allowed.has(column)) throw new Error(`${engine} patch column not allowlisted: ${column}`);
 }
 function insertValues2(job) {
@@ -35821,6 +37358,11 @@ function insertValues2(job) {
     if (component.source === "proposal_id") proposalIdentity = true;
   }
   if (!trustedTenant || !proposalIdentity) throw new Error("INSERT_DEDUP_REQUIRED");
+  const scope = principalScope2(job);
+  if (scope) {
+    if (Object.prototype.hasOwnProperty.call(values, scope.column)) throw new Error("PRINCIPAL_SCOPE_COLUMN_COLLISION");
+    values[scope.column] = scope.value;
+  }
   return values;
 }
 function identityForJob2(job, insertedPrimaryKey) {
@@ -35846,6 +37388,8 @@ function resultHash2(job, status, version) {
 }
 function reconciliationProjection2(job) {
   const columns = /* @__PURE__ */ new Set([job.target.primary_key.column, job.target.tenant_guard.column, ...job.allowed_columns]);
+  const scope = principalScope2(job);
+  if (scope) columns.add(scope.column);
   if (job.protocol_version === "3.0") {
     for (const member of job.frozen_set.members) {
       for (const column of Object.keys(member.before)) columns.add(column);
@@ -35867,39 +37411,68 @@ function reconciliationProjection2(job) {
 function buildMysqlReconciliationRead(job) {
   const projection = reconciliationProjection2(job).map(quoteMysqlIdentifier).join(", ");
   if (job.protocol_version === "4.0") {
+    const scope2 = principalScope2(job);
+    const where2 = [`${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+    const values2 = [job.target.tenant_guard.value];
+    if (scope2) {
+      where2.push(`${quoteMysqlIdentifier(scope2.column)} = ?`);
+      values2.push(scope2.value);
+    }
+    values2.push(...job.compensation.members.map((member) => member.primary_key.value));
     return {
       sql: `SELECT ${projection} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-WHERE ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?
+WHERE ${where2.join("\n  AND ")}
   AND ${quoteMysqlIdentifier(job.target.primary_key.column)} IN (${job.compensation.members.map(() => "?").join(", ")})
 ORDER BY ${quoteMysqlIdentifier(job.target.primary_key.column)} ASC`,
-      values: [job.target.tenant_guard.value, ...job.compensation.members.map((member) => member.primary_key.value)]
+      values: values2
     };
   }
   if (job.protocol_version === "3.0") {
     const identities = job.frozen_set.members.map(() => "?").join(", ");
+    const scope2 = principalScope2(job);
+    const where2 = [`${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+    const values2 = [job.target.tenant_guard.value];
+    if (scope2) {
+      where2.push(`${quoteMysqlIdentifier(scope2.column)} = ?`);
+      values2.push(scope2.value);
+    }
+    values2.push(...job.frozen_set.members.map((member) => member.primary_key.value));
     return {
       sql: `SELECT ${projection} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-WHERE ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?
+WHERE ${where2.join("\n  AND ")}
   AND ${quoteMysqlIdentifier(job.target.primary_key.column)} IN (${identities})
 ORDER BY ${quoteMysqlIdentifier(job.target.primary_key.column)} ASC`,
-      values: [job.target.tenant_guard.value, ...job.frozen_set.members.map((member) => member.primary_key.value)]
+      values: values2
     };
   }
   if (operationOf2(job) === "single_row_insert" && job.protocol_version === "2.0" && job.deduplication) {
+    const scope2 = principalScope2(job);
+    const where2 = job.deduplication.components.map((component) => `${quoteMysqlIdentifier(component.column)} = ?`);
+    const values2 = job.deduplication.components.map((component) => component.value);
+    if (scope2) {
+      where2.push(`${quoteMysqlIdentifier(scope2.column)} = ?`);
+      values2.push(scope2.value);
+    }
     return {
       sql: `SELECT ${projection} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-WHERE ${job.deduplication.components.map((component) => `${quoteMysqlIdentifier(component.column)} = ?`).join(" AND ")}
+WHERE ${where2.join(" AND ")}
 LIMIT 2`,
-      values: job.deduplication.components.map((component) => component.value)
+      values: values2
     };
   }
   if (job.target.primary_key.value === void 0) throw new Error("RECONCILIATION_TARGET_IDENTITY_REQUIRED");
+  const scope = principalScope2(job);
+  const where = [`${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`, `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+  const values = [job.target.primary_key.value, job.target.tenant_guard.value];
+  if (scope) {
+    where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+    values.push(scope.value);
+  }
   return {
     sql: `SELECT ${projection} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ?
-  AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?
+WHERE ${where.join("\n  AND ")}
 LIMIT 2`,
-    values: [job.target.primary_key.value, job.target.tenant_guard.value]
+    values
   };
 }
 async function inspectMysqlWritebackSource(job, databaseUrl) {
@@ -36162,7 +37735,14 @@ EXISTS (SELECT 1 FROM information_schema.USER_PRIVILEGES WHERE REPLACE(GRANTEE,
   if (count !== 1) throw new Error(count === 0 ? "VERSION_CONFLICT" : "MULTI_ROW_WRITE_BLOCKED");
   let resultVersion;
   if (job.protocol_version === "2.0" && job.version_advance) {
-    const [rows] = await connection.query(`SELECT ${quoteMysqlIdentifier(job.version_advance.column)} AS __synapsor_result_version FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ? AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ? FOR UPDATE`, [job.target.primary_key.value, job.target.tenant_guard.value]);
+    const where = [`${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`, `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+    const values = [job.target.primary_key.value, job.target.tenant_guard.value];
+    const scope = principalScope2(job);
+    if (scope) {
+      where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+      values.push(scope.value);
+    }
+    const [rows] = await connection.query(`SELECT ${quoteMysqlIdentifier(job.version_advance.column)} AS __synapsor_result_version FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${where.join(" AND ")} FOR UPDATE`, values);
     resultVersion = rows[0]?.__synapsor_result_version == null ? void 0 : scalar4(rows[0].__synapsor_result_version);
     verifyVersionAdvanced2(job, resultVersion);
   }
@@ -36170,6 +37750,8 @@ EXISTS (SELECT 1 FROM information_schema.USER_PRIVILEGES WHERE REPLACE(GRANTEE,
 }
 function compensationProjection2(job) {
   const columns = /* @__PURE__ */ new Set([job.target.primary_key.column, job.target.tenant_guard.column]);
+  const scope = principalScope2(job);
+  if (scope) columns.add(scope.column);
   for (const member of job.compensation.members) {
     for (const column of Object.keys(member.expected_state)) columns.add(column);
     for (const column of Object.keys(member.restore_values ?? {})) columns.add(column);
@@ -36178,10 +37760,15 @@ function compensationProjection2(job) {
   return [...columns].sort();
 }
 async function lockMysqlCompensationMembers(job, connection) {
-  const [rows] = await connection.query(
-    `SELECT ${compensationProjection2(job).map(quoteMysqlIdentifier).join(", ")} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ? AND ${quoteMysqlIdentifier(job.target.primary_key.column)} IN (${job.compensation.members.map(() => "?").join(", ")}) ORDER BY ${quoteMysqlIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`,
-    [job.target.tenant_guard.value, ...job.compensation.members.map((member) => member.primary_key.value)]
-  );
+  const where = [`${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+  const values = [job.target.tenant_guard.value];
+  const scope = principalScope2(job);
+  if (scope) {
+    where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+    values.push(scope.value);
+  }
+  values.push(...job.compensation.members.map((member) => member.primary_key.value));
+  const [rows] = await connection.query(`SELECT ${compensationProjection2(job).map(quoteMysqlIdentifier).join(", ")} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${where.join(" AND ")} AND ${quoteMysqlIdentifier(job.target.primary_key.column)} IN (${job.compensation.members.map(() => "?").join(", ")}) ORDER BY ${quoteMysqlIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`, values);
   return rows;
 }
 function rowsByCompensationIdentity2(job, rows) {
@@ -36232,6 +37819,8 @@ async function mutateMysqlCompensation(job, connection) {
   if (job.operation === "restore_insert") {
     for (const member of job.compensation.members) {
       const values = { ...member.restore_values, [job.target.primary_key.column]: member.primary_key.value, [job.target.tenant_guard.column]: job.target.tenant_guard.value };
+      const scope = principalScope2(job);
+      if (scope) values[scope.column] = scope.value;
       const columns = Object.keys(values).sort();
       const [inserted] = await connection.query(`INSERT INTO ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} (${columns.map(quoteMysqlIdentifier).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, columns.map((column) => values[column]));
       if (affectedRows(inserted) !== 1) throw new Error("COMPENSATION_ATOMICITY_VIOLATION");
@@ -36241,6 +37830,11 @@ async function mutateMysqlCompensation(job, connection) {
     for (const member of job.compensation.members) {
       const where = [`${quoteMysqlIdentifier(job.target.tenant_guard.column)} <=> ?`, `${quoteMysqlIdentifier(job.target.primary_key.column)} <=> ?`];
       const values = [job.target.tenant_guard.value, member.primary_key.value];
+      const scope = principalScope2(job);
+      if (scope) {
+        where.push(`${quoteMysqlIdentifier(scope.column)} <=> ?`);
+        values.push(scope.value);
+      }
       for (const [column, value] of Object.entries(member.expected_state)) {
         where.push(`${quoteMysqlIdentifier(column)} <=> ?`);
         values.push(value);
@@ -36258,6 +37852,11 @@ async function mutateMysqlCompensation(job, connection) {
       assignments.push(`${quoteMysqlIdentifier(version.column)} = ${quoteMysqlIdentifier(version.column)} + 1`);
       const where = [`${quoteMysqlIdentifier(job.target.tenant_guard.column)} <=> ?`, `${quoteMysqlIdentifier(job.target.primary_key.column)} <=> ?`];
       const values = [...columns.map((column) => restoreValues[column]), job.target.tenant_guard.value, member.primary_key.value];
+      const scope = principalScope2(job);
+      if (scope) {
+        where.push(`${quoteMysqlIdentifier(scope.column)} <=> ?`);
+        values.push(scope.value);
+      }
       for (const [column, value] of Object.entries(member.expected_state)) {
         where.push(`${quoteMysqlIdentifier(column)} <=> ?`);
         values.push(value);
@@ -36302,17 +37901,29 @@ async function mutateMysqlSet(job, connection) {
     if (job.operation === "set_update") {
       const assignments = Object.keys(job.patch).map((column) => `${quoteMysqlIdentifier(column)} = ?`);
       assignments.push(`${quoteMysqlIdentifier(job.version_advance.column)} = ${quoteMysqlIdentifier(job.version_advance.column)} + 1`);
-      const [updated] = await connection.query(
-        `UPDATE ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} SET ${assignments.join(", ")} WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ? AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ? AND ${quoteMysqlIdentifier(expected.column)} = ?`,
-        [...Object.values(job.patch), member.primary_key.value, job.target.tenant_guard.value, expected.value]
-      );
+      const where = [`${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`, `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+      const values = [...Object.values(job.patch), member.primary_key.value, job.target.tenant_guard.value];
+      const scope = principalScope2(job);
+      if (scope) {
+        where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+        values.push(scope.value);
+      }
+      where.push(`${quoteMysqlIdentifier(expected.column)} = ?`);
+      values.push(expected.value);
+      const [updated] = await connection.query(`UPDATE ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} SET ${assignments.join(", ")} WHERE ${where.join(" AND ")}`, values);
       if (affectedRows(updated) !== 1) throw new Error("SET_ATOMICITY_VIOLATION");
       memberEffects.push({ primary_key: member.primary_key, before_digest: member.before_digest, after_digest: member.after_digest });
     } else {
-      const [deleted] = await connection.query(
-        `DELETE FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ? AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ? AND ${quoteMysqlIdentifier(expected.column)} = ?`,
-        [member.primary_key.value, job.target.tenant_guard.value, expected.value]
-      );
+      const where = [`${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`, `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+      const values = [member.primary_key.value, job.target.tenant_guard.value];
+      const scope = principalScope2(job);
+      if (scope) {
+        where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+        values.push(scope.value);
+      }
+      where.push(`${quoteMysqlIdentifier(expected.column)} = ?`);
+      values.push(expected.value);
+      const [deleted] = await connection.query(`DELETE FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${where.join(" AND ")}`, values);
       if (affectedRows(deleted) !== 1) throw new Error("SET_ATOMICITY_VIOLATION");
       memberEffects.push({ primary_key: member.primary_key, before_digest: member.before_digest, tombstone_digest: member.tombstone_digest });
     }
@@ -36322,10 +37933,16 @@ async function mutateMysqlSet(job, connection) {
 async function lockMysqlFrozenMembers(job, connection) {
   const columns = /* @__PURE__ */ new Set([job.target.primary_key.column]);
   for (const member of job.frozen_set.members) for (const column of Object.keys(member.before)) columns.add(column);
-  const [rows] = await connection.query(
-    `SELECT ${[...columns].map(quoteMysqlIdentifier).join(", ")} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ? AND ${quoteMysqlIdentifier(job.target.primary_key.column)} IN (${job.frozen_set.members.map(() => "?").join(", ")}) ORDER BY ${quoteMysqlIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`,
-    [job.target.tenant_guard.value, ...job.frozen_set.members.map((member) => member.primary_key.value)]
-  );
+  const where = [`${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+  const values = [job.target.tenant_guard.value];
+  const scope = principalScope2(job);
+  if (scope) {
+    columns.add(scope.column);
+    where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+    values.push(scope.value);
+  }
+  values.push(...job.frozen_set.members.map((member) => member.primary_key.value));
+  const [rows] = await connection.query(`SELECT ${[...columns].map(quoteMysqlIdentifier).join(", ")} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${where.join(" AND ")} AND ${quoteMysqlIdentifier(job.target.primary_key.column)} IN (${job.frozen_set.members.map(() => "?").join(", ")}) ORDER BY ${quoteMysqlIdentifier(job.target.primary_key.column)} ASC FOR UPDATE`, values);
   if (rows.length !== job.frozen_set.row_count) return false;
   const byIdentity = new Map(rows.map((row) => [JSON.stringify(scalar4(row[job.target.primary_key.column])), row]));
   return job.frozen_set.members.every((member) => {
@@ -36350,16 +37967,20 @@ EXISTS (SELECT 1 FROM information_schema.USER_PRIVILEGES WHERE REPLACE(GRANTEE,
 }
 function validateBatchInsertMember2(job, member) {
   const dedupColumns = new Set(member.deduplication?.components.map((component) => component.column));
-  for (const column of Object.keys(member.after)) if (!job.allowed_columns.includes(column) && !dedupColumns.has(column)) throw new Error("BATCH_COLUMN_NOT_ALLOWED");
+  for (const column of Object.keys(member.after)) if (!job.allowed_columns.includes(column) && !dedupColumns.has(column) && column !== job.target.principal_scope?.column) throw new Error("BATCH_COLUMN_NOT_ALLOWED");
   if (!dedupColumns.has(job.target.primary_key.column) || !dedupColumns.has(job.target.tenant_guard.column)) throw new Error("BATCH_DEDUP_REQUIRED");
 }
 async function insertMysqlBatch(job, connection) {
   for (const member of job.frozen_set.members) {
     const components = member.deduplication.components;
-    const [existing] = await connection.query(
-      `SELECT 1 AS found FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${components.map((component) => `${quoteMysqlIdentifier(component.column)} = ?`).join(" AND ")} LIMIT 1 FOR UPDATE`,
-      components.map((component) => component.value)
-    );
+    const where = components.map((component) => `${quoteMysqlIdentifier(component.column)} = ?`);
+    const values = components.map((component) => component.value);
+    const scope = principalScope2(job);
+    if (scope) {
+      where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+      values.push(scope.value);
+    }
+    const [existing] = await connection.query(`SELECT 1 AS found FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${where.join(" AND ")} LIMIT 1 FOR UPDATE`, values);
     if (existing[0]) return { status: "conflict", affectedRows: 0, code: "INSERT_DEDUP_CONFLICT", targetIdentity: identityForJob2(job) };
   }
   const memberEffects = [];
@@ -36382,16 +38003,29 @@ async function lockTargetRow2(job, connection) {
     ...job.conflict_guard.kind === "version_column" ? [`${quoteMysqlIdentifier(job.conflict_guard.column)} AS __synapsor_conflict_value`] : [],
     ...inverseColumns.filter((column) => job.conflict_guard.kind !== "version_column" || column !== job.conflict_guard.column).map(quoteMysqlIdentifier)
   ].join(", ");
+  const where = [`${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`, `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`];
+  const values = [job.target.primary_key.value, job.target.tenant_guard.value];
+  const scope = principalScope2(job);
+  if (scope) {
+    where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+    values.push(scope.value);
+  }
   const [rows] = await connection.query(`SELECT ${projection} FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ?
-  AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?
-FOR UPDATE`, [job.target.primary_key.value, job.target.tenant_guard.value]);
+WHERE ${where.join("\n  AND ")}
+FOR UPDATE`, values);
   return rows[0];
 }
 async function insertMysql(job, connection) {
   if (job.protocol_version !== "2.0" || !job.deduplication) throw new Error("INSERT_DEDUP_REQUIRED");
   const components = job.deduplication.components;
-  const [existing] = await connection.query(`SELECT ${quoteMysqlIdentifier(job.target.primary_key.column)} AS __synapsor_primary_key FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${components.map((component) => `${quoteMysqlIdentifier(component.column)} = ?`).join(" AND ")}`, components.map((component) => component.value));
+  const where = components.map((component) => `${quoteMysqlIdentifier(component.column)} = ?`);
+  const values = components.map((component) => component.value);
+  const scope = principalScope2(job);
+  if (scope) {
+    where.push(`${quoteMysqlIdentifier(scope.column)} = ?`);
+    values.push(scope.value);
+  }
+  const [existing] = await connection.query(`SELECT ${quoteMysqlIdentifier(job.target.primary_key.column)} AS __synapsor_primary_key FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)} WHERE ${where.join(" AND ")}`, values);
   if (existing[0]) return { status: "conflict", affectedRows: 0, code: "INSERT_DEDUP_CONFLICT", targetIdentity: identityForJob2(job, existing[0].__synapsor_primary_key) };
   const insertion = buildMysqlInsert(job);
   const [inserted] = await connection.query(insertion.sql, insertion.values);
@@ -36431,10 +38065,13 @@ function resultFromExistingReceipt2(job, config, status, hash) {
 }
 function resultFromOutcome2(job, config, outcome, overrideCode, overrideHash) {
   const hash = overrideHash ?? resultHash2(job, outcome.status, outcome.resultVersion);
-  if (job.protocol_version === "4.0") return { protocol_version: "4.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority2(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob2(job), member_effects: outcome.memberEffects ?? [], ...outcome.status === "applied" || outcome.status === "already_applied" ? { inverse: outcome.inverse ?? compensationInverseFromJob(job) } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
-  if (job.protocol_version === "3.0") return { protocol_version: "3.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority2(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob2(job), set_digest: job.frozen_set.set_digest, member_effects: outcome.memberEffects ?? [], ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
-  if (job.protocol_version !== "2.0") return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: outcome.status, affected_rows: outcome.affectedRows, result_version: outcome.resultVersion == null ? void 0 : String(outcome.resultVersion), result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
-  return { protocol_version: "2.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority2(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identity: outcome.targetIdentity, result_version: outcome.resultVersion, before_digest: outcome.beforeDigest, after_digest: outcome.afterDigest, tombstone_digest: outcome.tombstoneDigest, ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+  if (job.protocol_version === "4.0") return wireResult2({ protocol_version: "4.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority2(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob2(job), member_effects: outcome.memberEffects ?? [], ...outcome.status === "applied" || outcome.status === "already_applied" ? { inverse: outcome.inverse ?? compensationInverseFromJob(job) } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+  if (job.protocol_version === "3.0") return wireResult2({ protocol_version: "3.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority2(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identities: identityForJob2(job), set_digest: job.frozen_set.set_digest, member_effects: outcome.memberEffects ?? [], ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+  if (job.protocol_version !== "2.0") return wireResult2({ protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: outcome.status, affected_rows: outcome.affectedRows, result_version: outcome.resultVersion == null ? void 0 : String(outcome.resultVersion), result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+  return wireResult2({ protocol_version: "2.0", job_id: job.job_id, runner_id: config.runnerId, operation: job.operation, receipt_authority: receiptAuthority2(config), status: outcome.status, affected_rows: outcome.affectedRows, target_identity: outcome.targetIdentity, result_version: outcome.resultVersion, before_digest: outcome.beforeDigest, after_digest: outcome.afterDigest, tombstone_digest: outcome.tombstoneDigest, ...job.inverse_capture && (outcome.status === "applied" || outcome.status === "already_applied") ? { inverse: job.inverse_capture } : {}, result_hash: hash, error_code: outcome.code ?? overrideCode, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function wireResult2(result) {
+  return Object.fromEntries(Object.entries(result).filter(([, value]) => value !== void 0));
 }
 function failedResult2(job, config, code) {
   return resultFromOutcome2(job, config, { status: "failed", affectedRows: 0, code, targetIdentity: identityForJob2(job) });
@@ -37383,6 +39020,7 @@ function parseAgentDsl(source) {
 }
 function compileAgentDslWithWarnings(source) {
   const ast = parseAgentDsl(source);
+  validatePrincipalScopeContexts(ast);
   const contexts = ast.contexts.map((context) => ({
     name: context.name,
     bindings: context.bindings,
@@ -37403,6 +39041,7 @@ function compileAgentDslWithWarnings(source) {
         table: capability.table,
         primary_key: capability.primaryKey,
         ...capability.tenantKey ? { tenant_key: capability.tenantKey } : {},
+        ...capability.principalScopeKey ? { principal_scope_key: capability.principalScopeKey } : {},
         ...capability.conflictKey ? { conflict_key: capability.conflictKey } : {}
       },
       args: specArgsFromDsl(capability.args),
@@ -37478,6 +39117,25 @@ function compileAgentDslWithWarnings(source) {
   assertValidContract(contract);
   return { contract: normalizeContract(contract), warnings: collectDslWarnings(ast) };
 }
+function validatePrincipalScopeContexts(ast) {
+  const contexts = new Map(ast.contexts.map((context) => [context.name, context]));
+  for (const capability of ast.capabilities) {
+    if (!capability.principalScopeKey)
+      continue;
+    const context = contexts.get(capability.context);
+    const principalBinding = context?.principalBinding;
+    const binding = principalBinding ? context?.bindings.find((item) => item.name === principalBinding) : void 0;
+    if (!context || !principalBinding || !binding || binding.required !== true) {
+      throw dslError(capability.line ?? 1, 1, "PRINCIPAL_SCOPE_BINDING_REQUIRED", `${capability.name} PRINCIPAL SCOPE KEY requires a context with a required PRINCIPAL BINDING`);
+    }
+    if (Object.prototype.hasOwnProperty.call(capability.args, capability.principalScopeKey)) {
+      throw dslError(capability.line ?? 1, 1, "MODEL_CONTROLLED_PRINCIPAL_SCOPE", `${capability.principalScopeKey} cannot be both a trusted principal scope and a model-facing ARG`);
+    }
+    if (capability.proposal?.allowedFields.includes(capability.principalScopeKey) || capability.proposal?.patch[capability.principalScopeKey]) {
+      throw dslError(capability.line ?? 1, 1, "PRINCIPAL_SCOPE_WRITE_FORBIDDEN", `${capability.principalScopeKey} is forced from trusted context and cannot be model-writeable`);
+    }
+  }
+}
 function validateAgentDsl(source) {
   try {
     const result = compileAgentDslWithWarnings(source);
@@ -37616,6 +39274,13 @@ function parseCapabilityBlock(block) {
       capability.tenantKey = tenant[1];
       continue;
     }
+    const principalScope3 = item.text.match(/^PRINCIPAL\s+SCOPE\s+KEY\s+([A-Za-z_][A-Za-z0-9_]*)$/i);
+    if (principalScope3?.[1]) {
+      if (capability.principalScopeKey)
+        throw dslError(item.line, 1, "DUPLICATE_PRINCIPAL_SCOPE", `${block.name} declares PRINCIPAL SCOPE KEY more than once`);
+      capability.principalScopeKey = principalScope3[1];
+      continue;
+    }
     const conflict = item.text.match(/^CONFLICT\s+GUARD\s+([A-Za-z_][A-Za-z0-9_]*)$/i);
     if (conflict?.[1]) {
       capability.conflictKey = conflict[1];
@@ -38549,6 +40214,10 @@ async function handleRequest(input) {
       sendJson(response, 403, { ok: false, error: "CSRF token required for proposal review actions" });
       return;
     }
+    if (await cloudLinkedGovernance(configPath)) {
+      sendJson(response, 403, { ok: false, error: "Cloud-linked proposals must be reviewed in Synapsor Cloud; local approval is disabled." });
+      return;
+    }
     if (await signedIdentityRequired(configPath)) {
       sendJson(response, 403, { ok: false, error: "This Runner requires a signed operator identity. Approve with the CLI using --identity and --identity-key." });
       return;
@@ -38574,6 +40243,10 @@ async function handleRequest(input) {
       sendJson(response, 403, { ok: false, error: "CSRF token required for proposal review actions" });
       return;
     }
+    if (await cloudLinkedGovernance(configPath)) {
+      sendJson(response, 403, { ok: false, error: "Cloud-linked proposals must be reviewed in Synapsor Cloud; local rejection is disabled." });
+      return;
+    }
     if (await signedIdentityRequired(configPath)) {
       sendJson(response, 403, { ok: false, error: "This Runner requires a signed operator identity. Reject with the CLI using --identity and --identity-key." });
       return;
@@ -38615,6 +40288,10 @@ async function signedIdentityRequired(configPath) {
   const config = await readRunnerConfig(configPath);
   return isRecord6(config.operator_identity) && ["signed_key", "jwt_oidc"].includes(String(config.operator_identity.provider));
 }
+async function cloudLinkedGovernance(configPath) {
+  const config = await readRunnerConfig(configPath);
+  return isRecord6(config.governance) && config.governance.mode === "cloud_linked";
+}
 function buildSummary(config, configPath, storePath) {
   const validation = validateRunnerCapabilityConfig(config);
   const sources = Object.fromEntries(Object.entries(asRecord(config.sources)).map(([name, source]) => {
@@ -39778,6 +41455,17 @@ function lintContract(contract, options = {}) {
       add({ code: "KEPT_OUT_REVIEW_NOT_RECORDED", severity: "warning", path: `${base}.kept_out_fields`, message: `${capability.name} does not record an explicit kept-out field review; lint cannot infer which columns are sensitive.` });
     }
     if (capability.evidence?.required !== true) add({ code: "EVIDENCE_NOT_REQUIRED", severity: "warning", path: `${base}.evidence.required`, message: `${capability.name} does not require evidence.` });
+    if (!capability.subject.principal_scope_key) {
+      const possibleOwnerFields = [.../* @__PURE__ */ new Set([...capability.visible_fields, ...capability.kept_out_fields ?? []])].filter((field) => /^(?:assigned_to|assignee_id|owner_id|principal_id|user_id|case_manager_id)$/i.test(field));
+      if (possibleOwnerFields.length > 0) {
+        add({
+          code: "PRINCIPAL_SCOPE_REVIEW_RECOMMENDED",
+          severity: "info",
+          path: `${base}.subject.principal_scope_key`,
+          message: `${capability.name} includes ${possibleOwnerFields.join(", ")}, which may represent row ownership. Review whether PRINCIPAL SCOPE KEY is appropriate; this is only a naming heuristic and is not data classification.`
+        });
+      }
+    }
     for (const [argName, arg] of Object.entries(capability.args)) lintArgument(add, `${base}.args.${argName}`, argName, arg);
     if (options.runnerConfig && capability.source && !configSources.has(capability.source)) {
       add({ code: "RUNNER_SOURCE_UNRESOLVED", severity: "error", path: `${base}.source`, message: `${capability.name} references source ${capability.source}, which is absent from runner config.` });
@@ -39836,6 +41524,14 @@ function explainContext(context) {
 function explainCapability(capability, context) {
   const proposal = capability.proposal;
   const selection = (proposal?.operation?.selection ?? capability.aggregate?.selection)?.all.map((term) => `${term.column} = ${scalarText(term.value)}`);
+  const principalBinding = context?.bindings.find((binding) => binding.name === context.principal_binding);
+  const tenantColumn = capability.subject.tenant_key;
+  const principalColumn = capability.subject.principal_scope_key;
+  const effectivePredicate = [
+    ...tenantColumn ? [`${tenantColumn} = <trusted tenant>`] : [],
+    ...principalColumn ? [`${principalColumn} = <trusted principal>`] : [],
+    ...(proposal?.operation?.selection ?? capability.aggregate?.selection)?.all.map((term) => `${term.column} ${term.operator} <reviewed value>`) ?? []
+  ].join(" AND ") || "no row predicate declared";
   return {
     name: capability.name,
     ...capability.description ? { description: capability.description } : {},
@@ -39846,8 +41542,16 @@ function explainCapability(capability, context) {
     target: capability.subject.resource ?? ([capability.subject.schema, capability.subject.table].filter(Boolean).join(".") || "unresolved target"),
     trusted_scope: [
       ...context?.tenant_binding ? [`tenant from context binding ${context.tenant_binding}`] : capability.subject.single_tenant_dev ? ["single-tenant development scope"] : ["no tenant binding declared"],
-      ...context?.principal_binding ? [`principal from context binding ${context.principal_binding}`] : ["no principal binding declared"]
+      ...principalColumn && context?.principal_binding ? [`principal row lock ${principalColumn} from required ${principalBinding?.source ?? "trusted"} binding ${context.principal_binding}`] : context?.principal_binding ? [`principal identity from context binding ${context.principal_binding}; no principal row lock declared`] : ["no principal binding declared"]
     ],
+    ...tenantColumn || principalColumn ? { row_scope: {
+      ...tenantColumn ? { tenant_column: tenantColumn } : {},
+      ...context?.tenant_binding ? { tenant_binding: context.tenant_binding } : {},
+      ...principalColumn ? { principal_column: principalColumn } : {},
+      ...context?.principal_binding ? { principal_binding: context.principal_binding } : {},
+      ...principalBinding ? { principal_provider: principalBinding.source, principal_required: principalBinding.required === true } : {},
+      effective_predicate: effectivePredicate
+    } } : {},
     arguments: Object.entries(capability.args).map(([name, arg]) => explainArgument(name, arg)),
     ...capability.lookup ? { lookup: `${capability.subject.primary_key ?? "primary key"} from argument ${capability.lookup.id_from_arg}` } : {},
     ...selection?.length ? { fixed_selection: selection } : {},
@@ -39925,6 +41629,11 @@ function formatExplanationMarkdown(explanation) {
     lines.push(`### ${capability.name}`, "", capability.description ?? "No capability description was provided.", "");
     lines.push(`- Kind: ${capability.kind}`, `- Target: \`${capability.target}\``, `- Context: \`${capability.context}\``);
     for (const scope of capability.trusted_scope) lines.push(`- Trusted scope: ${scope}`);
+    if (capability.row_scope) {
+      if (capability.row_scope.tenant_column) lines.push(`- Tenant row lock: \`${capability.row_scope.tenant_column}\` from binding \`${capability.row_scope.tenant_binding ?? "not declared"}\``);
+      if (capability.row_scope.principal_column) lines.push(`- Principal row lock: \`${capability.row_scope.principal_column}\` from ${capability.row_scope.principal_required ? "required " : ""}${capability.row_scope.principal_provider ?? "trusted"} binding \`${capability.row_scope.principal_binding ?? "not declared"}\``);
+      lines.push(`- Effective row predicate: \`${capability.row_scope.effective_predicate}\``);
+    }
     lines.push(`- Visible fields: ${capability.visible_fields.map((field) => `\`${field}\``).join(", ") || "none"}`);
     lines.push(`- Kept out: ${capability.kept_out_fields.map((field) => `\`${field}\``).join(", ") || "no explicit list"}`);
     lines.push(`- Evidence: ${capability.evidence}`);
@@ -39977,6 +41686,7 @@ import { isDeepStrictEqual } from "node:util";
 var kinds = /* @__PURE__ */ new Set([
   "tool_allow",
   "tool_deny",
+  "cross_principal_deny",
   "hide_fields",
   "argument_constraint",
   "transition_guard",
@@ -40119,6 +41829,53 @@ async function runStaticAssertion(test, config) {
 async function runLiveAssertion(test, config, env, storePath) {
   const trusted = test.trusted_context;
   if (!trusted) throw new ContractAssertionFailure("TRUSTED_CONTEXT_REQUIRED", `${test.kind} requires trusted_context in test setup`);
+  if (test.kind === "cross_principal_deny") {
+    const other = test.other_trusted_context;
+    if (!other) throw new ContractAssertionFailure("OTHER_TRUSTED_CONTEXT_REQUIRED", "cross_principal_deny requires other_trusted_context");
+    if (other.tenant_id !== trusted.tenant_id) throw new ContractAssertionFailure("CROSS_PRINCIPAL_TENANT_MISMATCH", "cross_principal_deny contexts must use the same tenant");
+    if (other.principal === trusted.principal) throw new ContractAssertionFailure("CROSS_PRINCIPAL_IDENTITY_MATCH", "cross_principal_deny contexts must use different principals");
+    const ownerRuntime = createMcpRuntime(config, {
+      env,
+      storePath,
+      resultFormat: 2,
+      trustedContext: { tenant_id: trusted.tenant_id, principal: trusted.principal, provenance: trusted.provenance ?? "static_dev" }
+    });
+    const deniedRuntime = createMcpRuntime(config, {
+      env,
+      storePath,
+      resultFormat: 2,
+      trustedContext: { tenant_id: other.tenant_id, principal: other.principal, provenance: other.provenance ?? "static_dev" }
+    });
+    try {
+      const allowed = await ownerRuntime.callTool(test.capability, test.args ?? {});
+      if (allowed.ok !== true) throw new ContractAssertionFailure("OWNER_ACCESS_NOT_PROVEN", "the owning principal could not access the reviewed row");
+      const denied = await deniedRuntime.callTool(test.capability, test.args ?? {});
+      const code = isRecord8(denied.error) && typeof denied.error.code === "string" ? denied.error.code : void 0;
+      const expected = test.expected_code ?? "NOT_FOUND_IN_TENANT";
+      if (denied.ok === true || code !== expected) throw new ContractAssertionFailure("CROSS_PRINCIPAL_DENIAL_MISMATCH", `expected generic ${expected}, got ${code ?? "success"}`);
+      const serialized = JSON.stringify(denied);
+      const deniedEvidenceHandle = isRecord8(denied.evidence) && typeof denied.evidence.bundle_id === "string" ? denied.evidence.bundle_id : void 0;
+      const deniedProposalHandle = isRecord8(denied.proposal) && typeof denied.proposal.id === "string" ? denied.proposal.id : void 0;
+      if (deniedEvidenceHandle || deniedProposalHandle || /\b(?:ev|wrp|receipt|replay)_[A-Za-z0-9_.-]+\b/.test(serialized)) {
+        throw new ContractAssertionFailure("CROSS_PRINCIPAL_HANDLE_LEAK", "denied result exposed a local resource handle");
+      }
+      const evidenceId = isRecord8(allowed.evidence) && typeof allowed.evidence.bundle_id === "string" ? allowed.evidence.bundle_id : void 0;
+      if (!evidenceId) throw new ContractAssertionFailure("OWNER_EVIDENCE_NOT_PROVEN", "the owning principal call did not create an evidence handle");
+      try {
+        await deniedRuntime.readResource(`synapsor://evidence/${evidenceId}`);
+        throw new ContractAssertionFailure("CROSS_PRINCIPAL_HANDLE_LEAK", "another principal could read the owner's evidence handle");
+      } catch (error) {
+        if (error instanceof ContractAssertionFailure) throw error;
+        if (!isRecord8(error) || error.code !== "RESOURCE_NOT_FOUND") {
+          throw new ContractAssertionFailure("CROSS_PRINCIPAL_HANDLE_DENIAL_MISMATCH", "another principal's evidence handle did not fail with generic RESOURCE_NOT_FOUND");
+        }
+      }
+      return;
+    } finally {
+      await ownerRuntime.close();
+      await deniedRuntime.close();
+    }
+  }
   const runtime = createMcpRuntime(config, {
     env,
     storePath,
@@ -40161,7 +41918,7 @@ async function runLiveAssertion(test, config, env, storePath) {
 }
 function validateAssertion(raw, index, ids) {
   if (!isRecord8(raw)) throw new Error(`CONTRACT_TEST_INVALID: tests[${index}] must be an object`);
-  rejectUnknownKeys(raw, /* @__PURE__ */ new Set(["id", "kind", "capability", "args", "trusted_context", "expected_code", "fields", "argument", "expected"]), `$.tests[${index}]`);
+  rejectUnknownKeys(raw, /* @__PURE__ */ new Set(["id", "kind", "capability", "args", "trusted_context", "other_trusted_context", "expected_code", "fields", "argument", "expected"]), `$.tests[${index}]`);
   const id = requiredString(raw.id, `tests[${index}].id`);
   if (ids.has(id)) throw new Error(`CONTRACT_TEST_ID_DUPLICATE: ${id}`);
   ids.add(id);
@@ -40174,6 +41931,7 @@ function validateAssertion(raw, index, ids) {
     capability,
     ...isRecord8(raw.args) ? { args: raw.args } : {},
     ...isRecord8(raw.trusted_context) ? { trusted_context: trustedContextFromManifest(raw.trusted_context, id) } : {},
+    ...isRecord8(raw.other_trusted_context) ? { other_trusted_context: trustedContextFromManifest(raw.other_trusted_context, `${id}.other_trusted_context`) } : {},
     ...typeof raw.expected_code === "string" ? { expected_code: raw.expected_code } : {},
     ...Array.isArray(raw.fields) ? { fields: raw.fields.map(String) } : {},
     ...typeof raw.argument === "string" ? { argument: raw.argument } : {},
@@ -40203,7 +41961,7 @@ function liveEngine(config) {
   return engines.size === 1 ? [...engines][0] : void 0;
 }
 function requiresLive(test) {
-  return ["tool_allow", "tool_deny", "source_unchanged_before_approval"].includes(test.kind);
+  return ["tool_allow", "tool_deny", "cross_principal_deny", "source_unchanged_before_approval"].includes(test.kind);
 }
 function trustedContextFromManifest(record, id) {
   const provenance = record.provenance;
@@ -40995,7 +42753,7 @@ function rate(value) {
 // apps/runner/package.json
 var package_default = {
   name: "@synapsor/runner",
-  version: "1.4.121",
+  version: "1.4.122",
   description: "Stop giving AI agents execute_sql; expose reviewed Postgres/MySQL MCP actions with proposals, approval, writeback, and replay.",
   license: "Apache-2.0",
   type: "module",
@@ -41088,7 +42846,7 @@ var package_default = {
 // packages/dsl/package.json
 var package_default2 = {
   name: "@synapsor/dsl",
-  version: "1.4.2",
+  version: "1.4.3",
   description: "SQL-like Synapsor authoring frontend for canonical @synapsor/spec contracts.",
   license: "Apache-2.0",
   type: "module",
@@ -41109,7 +42867,7 @@ var package_default2 = {
     test: "vitest run"
   },
   dependencies: {
-    "@synapsor/spec": "workspace:^1.4.1"
+    "@synapsor/spec": "workspace:^1.4.2"
   },
   devDependencies: {
     typescript: "^5.7.0",
@@ -41142,7 +42900,7 @@ var package_default2 = {
 // packages/spec/package.json
 var package_default3 = {
   name: "@synapsor/spec",
-  version: "1.4.1",
+  version: "1.4.2",
   description: "Canonical Synapsor contract schemas, types, validation, and conformance fixtures.",
   license: "Apache-2.0",
   type: "module",
@@ -44001,7 +45759,13 @@ async function localToolNames(config, checks) {
   }
 }
 function formatLocalDoctorReport(report) {
-  const lines = [`Synapsor Runner doctor: ${report.ok ? "ok" : "failed"}`, `Config: ${report.config_path}`, `Mode: ${report.mode}`];
+  const lines = [
+    `Synapsor Runner doctor: ${report.ok ? "ok" : "failed"}`,
+    `Config: ${report.config_path}`,
+    `Mode: ${report.mode}`,
+    `Governance authority: ${report.governance.authority_mode}`,
+    `Evidence residency: ${report.governance.evidence_residency}`
+  ];
   if (report.tools.length) {
     lines.push("Exposed MCP tools:");
     for (const tool of report.tools) lines.push(`  - ${tool}`);
@@ -44023,6 +45787,9 @@ function formatLocalDoctorMarkdown(report) {
     `- Node version: ${process2.versions.node}`,
     `- Config: ${report.config_path}`,
     `- Mode: ${report.mode}`,
+    `- Governance authority: ${report.governance.authority_mode}`,
+    `- Evidence residency: ${report.governance.evidence_residency}`,
+    `- Queue proposals while Cloud is unavailable: ${report.governance.queue_when_unavailable ? "yes" : "no"}`,
     `- Status: ${report.ok ? "ok" : "needs attention"}`,
     "",
     "## Semantic Tools",
@@ -44358,6 +46125,7 @@ async function localDoctor(args) {
   }
   checks.push(...await sharedPostgresLedgerDoctorChecks(parsed));
   checks.push(...graduatedTrustDoctorChecks(parsed));
+  const governance = await cloudLinkedGovernanceDoctorStatus(parsed, args, checks);
   const contextsToCheck = trustedContextsForDoctor(parsed);
   for (const [contextName, contextValues] of contextsToCheck) {
     const tenantEnv = String(contextValues.tenant_id_env ?? "SYNAPSOR_TENANT_ID");
@@ -44482,6 +46250,7 @@ async function localDoctor(args) {
     config_path: configPath,
     checks,
     tools: tools2,
+    governance,
     store_stats: await localDoctorStoreStats(optionalArg(args, "--store") ?? parsed.storage?.sqlite_path)
   };
   if (args.includes("--report")) {
@@ -44498,6 +46267,58 @@ async function localDoctor(args) {
   }
   return report.ok ? 0 : 1;
 }
+async function cloudLinkedGovernanceDoctorStatus(config, args, checks) {
+  if (config.governance?.mode !== "cloud_linked") {
+    checks.push({ name: "governance:authority", ok: true, level: "pass", message: "Governance authority is local-only; no Synapsor Cloud account is required." });
+    return { authority_mode: "local_only", evidence_residency: "metadata_only", queue_when_unavailable: false };
+  }
+  const storePath = optionalArg(args, "--store") ?? config.storage?.sqlite_path ?? "./.synapsor/local.db";
+  let store;
+  let synchronizer;
+  try {
+    store = createDefaultRuntimeStore(config, process2.env, storePath);
+    synchronizer = new CloudLinkedSynchronizer(config, store, process2.env);
+    const status = await synchronizer.status();
+    checks.push({
+      name: "governance:authority",
+      ok: true,
+      level: "pass",
+      message: `Governance authority is Synapsor Cloud; local store ${storePath} is an operational spool/mirror and is never uploaded.`
+    });
+    checks.push({
+      name: "governance:evidence-residency",
+      ok: true,
+      level: "pass",
+      message: "Evidence residency is metadata_only; source rows, SQL details, kept-out fields, credentials, and replay payloads remain local."
+    });
+    const unhealthy = status.dead_letter > 0 || status.reconciliation_required > 0;
+    const lagging = status.pending > 0 || status.leased > 0;
+    checks.push({
+      name: "governance:outbox",
+      ok: !unhealthy,
+      level: unhealthy ? "fail" : lagging ? "warn" : "pass",
+      message: unhealthy ? `Cloud outbox needs operator attention: ${status.dead_letter} dead-letter and ${status.reconciliation_required} reconciliation-required event(s). Run ${cliCommandName()} cloud outbox inspect latest.` : lagging ? `Cloud outbox has ${status.pending} pending and ${status.leased} leased event(s); source writes remain blocked until Cloud governance completes.` : "Cloud outbox has no pending, leased, dead-letter, or reconciliation-required events."
+    });
+    return { ...status, queue_when_unavailable: config.governance.queue_when_unavailable !== false };
+  } catch (error) {
+    const errorCode = error instanceof Error && "code" in error ? String(error.code ?? "CLOUD_LINKED_DOCTOR_FAILED") : "CLOUD_LINKED_DOCTOR_FAILED";
+    checks.push({
+      name: "governance:cloud-connection",
+      ok: false,
+      level: "fail",
+      message: `Cloud-linked governance configuration could not be opened (${errorCode}). Check the reviewed connection file and Runner credential environment; no local approval fallback is allowed.`
+    });
+    return {
+      authority_mode: "cloud_linked",
+      evidence_residency: "metadata_only",
+      queue_when_unavailable: config.governance.queue_when_unavailable !== false,
+      connection_error_code: errorCode
+    };
+  } finally {
+    await synchronizer?.stop();
+    await store?.close();
+  }
+}
 function graduatedTrustDoctorChecks(config) {
   const trust = config.graduated_trust;
   if (trust?.enabled !== true) {
@@ -44828,6 +46649,11 @@ async function revert(args) {
     if (capability.reversibility?.mode !== "reviewed_inverse") throw new Error(`REVERSIBILITY_NOT_REVIEWED: capability ${capability.name} does not declare reviewed inverse authority`);
     const trusted = trustedCliContext(config, capability, process2.env);
     if (trusted.tenant_id !== forward.tenant_id) throw new Error("REVERSAL_TENANT_MISMATCH: current trusted tenant does not own the forward proposal");
+    const forwardPrincipalScope = forward.change_set.guards.principal_scope;
+    if (capability.target.principal_scope_key) {
+      if (!forwardPrincipalScope?.value || forwardPrincipalScope.column !== capability.target.principal_scope_key) throw new Error("REVERSAL_PRINCIPAL_SCOPE_MISSING: forward proposal does not preserve reviewed principal authority");
+      if (String(forwardPrincipalScope.value) !== trusted.principal) throw new Error("REVERSAL_PRINCIPAL_MISMATCH: current trusted principal does not own the forward proposal");
+    }
     const identity = await operatorIdentityForDecision({ args, config, configPath, proposal: forward, action: "revert", reason: optionalArg(args, "--reason") });
     const receipt = [...store.receipts(forward.proposal_id)].reverse().find((item) => item.status === "applied" || item.status === "already_applied");
     if (!receipt) {
@@ -44923,7 +46749,7 @@ function createCompensationProposal(input) {
     patch,
     after,
     compensation: { descriptor: input.inverse, forward_receipt_hash: input.receiptHash },
-    guards: { tenant: input.inverse.tenant_guard, allowed_columns: input.inverse.allowed_columns },
+    guards: { tenant: input.inverse.tenant_guard, ...input.inverse.principal_scope ? { principal_scope: input.inverse.principal_scope } : {}, allowed_columns: input.inverse.allowed_columns },
     evidence: { bundle_id: evidenceId, query_fingerprint: queryFingerprint, items: evidenceItems },
     approval: {
       status: "pending",
@@ -44964,6 +46790,7 @@ async function apply(args) {
   const dryRun = args.includes("--dry-run") || process2.env.SYNAPSOR_DRY_RUN === "true";
   const configPath = optionalArg(args, "--config") ?? (await fileExists("synapsor.runner.json") ? "synapsor.runner.json" : void 0);
   const runtimeConfig = configPath ? await optionalRuntimeConfig(configPath) : void 0;
+  if (!dryRun) assertLocalGovernanceMutationAllowed(runtimeConfig, "apply --job");
   if (runtimeConfig && runtimeStoreBridgeRequired(args, runtimeConfig)) {
     return withSharedPostgresRuntimeStoreBridge(args, runtimeConfig, "apply --job", (bridgeStorePath) => apply(argsWithRuntimeStoreBridge(args, bridgeStorePath)));
   }
@@ -45063,6 +46890,7 @@ async function applyAllApproved(args) {
   const configPath = optionalArg(args, "--config") ?? "synapsor.runner.json";
   const storePath = optionalArg(args, "--store") ?? process2.env.SYNAPSOR_LOCAL_STORE ?? "./.synapsor/local.db";
   const config = await optionalRuntimeConfig(configPath);
+  assertLocalGovernanceMutationAllowed(config, "apply --all-approved");
   if (config && runtimeStoreBridgeRequired(args, config)) {
     return withSharedPostgresRuntimeStoreBridge(args, config, "apply --all-approved", (bridgeStorePath) => applyAllApproved(argsWithRuntimeStoreBridge(args, bridgeStorePath)));
   }
@@ -45171,6 +46999,7 @@ async function applyProposal(args, proposalId) {
   const runnerId = optionalArg(args, "--runner") ?? process2.env.SYNAPSOR_RUNNER_ID ?? "local_runner";
   const workerAttempt = Number(optionalArg(args, "--worker-attempt") ?? "1");
   const config = await readRuntimeConfig(configPath);
+  assertLocalGovernanceMutationAllowed(config, "apply");
   if (config && runtimeStoreBridgeRequired(args, config)) {
     return withSharedPostgresRuntimeStoreBridge(args, config, `apply ${proposalId}`, (bridgeStorePath) => applyProposal(argsWithRuntimeStoreBridge(args, bridgeStorePath), proposalId));
   }
@@ -45206,6 +47035,20 @@ async function applyProposal(args, proposalId) {
       identity_verified: identity.verified,
       required_role: config.operator_identity?.apply_roles?.join(",") || void 0
     });
+    const proposalScope = proposal.change_set.guards.principal_scope;
+    if (capability.target.principal_scope_key) {
+      if (!proposalScope || proposalScope.column !== capability.target.principal_scope_key || proposalScope.value === void 0) {
+        throw new Error(`proposal ${proposal.proposal_id} is missing its reviewed principal scope`);
+      }
+      if (proposalScope.provider === "environment" || proposalScope.provider === "static_dev") {
+        const current = trustedCliContext(config, capability, process2.env);
+        if (current.tenant_id !== proposal.tenant_id || current.principal !== String(proposalScope.value)) {
+          throw new Error("current trusted tenant/principal cannot apply this proposal");
+        }
+      }
+    } else if (proposalScope) {
+      throw new Error(`proposal ${proposal.proposal_id} carries unreviewed principal scope`);
+    }
     const executorName = proposalExecutorName(proposal, capability);
     if (executorName === "none" || executorName === "cloud_worker") {
       throw new Error(`proposal ${resolvedProposalId} is not locally applyable; capability ${capability.name} declares ${executorName === "none" ? "no local writeback" : "cloud-worker writeback"}.`);
@@ -45471,6 +47314,7 @@ function prepareHandlerProposal(store, proposal, runnerId, workerAttempt = 1) {
         primary_key: changeSet.source.primary_key
       },
       tenant_guard: changeSet.guards.tenant,
+      ...changeSet.guards.principal_scope ? { principal_scope: changeSet.guards.principal_scope } : {},
       allowed_columns: changeSet.guards.allowed_columns,
       before: changeSet.before,
       patch: changeSet.patch,
@@ -45761,7 +47605,7 @@ async function runCommandHandler(command, args, request, timeoutMs) {
     child.stdin.end();
   });
 }
-async function verifyLocalWritebackAuthority(job, configPath, storePath) {
+async function verifyLocalWritebackAuthority(job, configPath, storePath, options = {}) {
   const config = await readRuntimeConfig(configPath);
   const validation = validateRunnerCapabilityConfig(config);
   if (!validation.ok) {
@@ -45785,6 +47629,22 @@ async function verifyLocalWritebackAuthority(job, configPath, storePath) {
   if (!matching) {
     throw new Error("writeback job does not match any reviewed proposal capability in local config");
   }
+  const reviewedPrincipalColumn = matching.target.principal_scope_key;
+  const jobPrincipalScope = job.target.principal_scope;
+  if (reviewedPrincipalColumn) {
+    if (!jobPrincipalScope || jobPrincipalScope.column !== reviewedPrincipalColumn) {
+      throw new Error("writeback job is missing or changes the reviewed principal scope");
+    }
+  } else if (jobPrincipalScope) {
+    throw new Error("writeback job adds principal scope not present in the reviewed capability");
+  }
+  if (options.cloudApproved) {
+    const leasedContract = "contract" in job ? job.contract : void 0;
+    if (!leasedContract?.digest) throw new Error("Cloud writeback job is missing its immutable contract digest");
+    if (!matching.contract_provenance || matching.contract_provenance.digest !== leasedContract.digest) {
+      throw new Error("Cloud writeback job contract digest does not match the reviewed local contract");
+    }
+  }
   const reviewedAllowed = new Set(matching.allowed_columns ?? []);
   for (const column of job.allowed_columns) {
     if (!reviewedAllowed.has(column)) {
@@ -45804,13 +47664,35 @@ async function verifyLocalWritebackAuthority(job, configPath, storePath) {
     try {
       const proposal = store.getProposal(job.proposal_id);
       if (!proposal) throw new Error(`local proposal not found for writeback job: ${job.proposal_id}`);
-      if (proposal.state !== "approved" && proposal.state !== "pending_worker" && proposal.state !== "applied") {
-        throw new Error(`local proposal ${job.proposal_id} is ${proposal.state}, not approved for writeback`);
+      const allowedStates = options.cloudApproved ? /* @__PURE__ */ new Set(["pending_review", "approved", "pending_worker", "applied"]) : /* @__PURE__ */ new Set(["approved", "pending_worker", "applied"]);
+      if (!allowedStates.has(proposal.state)) {
+        throw new Error(`local proposal ${job.proposal_id} is ${proposal.state}, not eligible for ${options.cloudApproved ? "Cloud-approved" : "local-approved"} writeback`);
       }
       if (proposal.proposal_hash !== job.approval_id) {
         throw new Error("writeback approval/proposal digest does not match local proposal");
       }
-      await verifyStoredApprovalAuthority(config, configPath, store, proposal, matching);
+      const proposalPrincipalScope = proposal.change_set.guards.principal_scope;
+      if (reviewedPrincipalColumn) {
+        if (!proposalPrincipalScope || proposalPrincipalScope.column !== reviewedPrincipalColumn || proposalPrincipalScope.value === void 0) {
+          throw new Error("local proposal is missing its immutable principal scope");
+        }
+        if (!jobPrincipalScope || jobPrincipalScope.value_fingerprint !== proposalPrincipalScope.value_fingerprint || jobPrincipalScope.binding !== proposalPrincipalScope.binding || jobPrincipalScope.provider !== proposalPrincipalScope.provider) {
+          throw new Error("writeback principal scope does not match the immutable local proposal");
+        }
+        if (jobPrincipalScope.value !== void 0 && jobPrincipalScope.value !== proposalPrincipalScope.value) {
+          throw new Error("writeback principal scope value does not match the immutable local proposal");
+        }
+        jobPrincipalScope.value = proposalPrincipalScope.value;
+        if (!options.cloudApproved && (proposalPrincipalScope.provider === "environment" || proposalPrincipalScope.provider === "static_dev")) {
+          const current = trustedCliContext(config, matching, process2.env);
+          if (current.tenant_id !== proposal.tenant_id || current.principal !== String(proposalPrincipalScope.value)) {
+            throw new Error("current trusted tenant/principal cannot apply this proposal");
+          }
+        }
+      } else if (proposalPrincipalScope) {
+        throw new Error("local proposal carries principal scope outside the reviewed capability");
+      }
+      if (!options.cloudApproved) await verifyStoredApprovalAuthority(config, configPath, store, proposal, matching);
     } finally {
       store.close();
     }
@@ -45855,6 +47737,7 @@ function capabilityMatchesJob(capability, job) {
   if (capability.target.table !== job.target.table) return false;
   if (capability.target.primary_key !== job.target.primary_key.column) return false;
   if (!capability.target.tenant_key || capability.target.tenant_key !== job.target.tenant_guard.column) return false;
+  if ((capability.target.principal_scope_key ?? void 0) !== (job.target.principal_scope?.column ?? void 0)) return false;
   const reviewedOperation = capability.operation?.kind ?? "update";
   if (job.protocol_version === protocolVersions.normalizedWritebackJobV4) {
     if (capability.reversibility?.mode !== "reviewed_inverse") return false;
@@ -45900,18 +47783,89 @@ function capabilityMatchesJob(capability, job) {
   return Object.keys(job.patch).every((column) => reviewedAllowed.has(column));
 }
 async function start(args = []) {
-  if (args.length > 0) {
-    if (args.includes("--from-env") || args.includes("--schema") || args.includes("--mode") || args.includes("--engine")) {
+  if (args.includes("--from-env") || args.includes("--schema") || args.includes("--mode") || args.includes("--engine")) {
+    if (args.length > 0) {
       return onboard(["db", ...args]);
     }
-    throw new Error(`start accepts own-database onboarding flags such as --from-env DATABASE_URL, or no flags for the legacy polling worker. Unknown start arguments: ${args.join(" ")}`);
   }
+  const workerOptions = /* @__PURE__ */ new Map();
+  const once = args.includes("--once");
+  for (let index = 0; index < args.length; index += 1) {
+    const flag = args[index];
+    if (flag === "--once") continue;
+    if (flag !== "--config" && flag !== "--store") {
+      throw new Error(`start accepts own-database onboarding flags or Cloud worker flags --config, --store, and --once. Unknown argument: ${flag}`);
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
+    workerOptions.set(flag, value);
+    index += 1;
+  }
+  const configPath = workerOptions.get("--config");
+  const storePath = workerOptions.get("--store");
+  if (Boolean(configPath) !== Boolean(storePath)) throw new Error("Cloud worker mode requires both --config and --store");
+  if (once && (!configPath || !storePath)) throw new Error("Cloud worker --once requires both --config and --store so local reviewed authority is rechecked");
   const config = loadConfig();
+  const cloudLinkedWorker = configPath && storePath ? createCloudLinkedWorkerSync(configPath, storePath) : void 0;
+  if (once) {
+    const reviewedConfigPath = configPath;
+    const reviewedStorePath = storePath;
+    if (!reviewedConfigPath || !reviewedStorePath) {
+      throw new Error("Cloud worker --once requires both --config and --store so local reviewed authority is rechecked");
+    }
+    try {
+      await cloudLinkedWorker?.synchronizer.drainOnce();
+      const completed = await runOnce(
+        config,
+        adapters,
+        (job) => verifyLocalWritebackAuthority(job, reviewedConfigPath, reviewedStorePath, { cloudApproved: true }),
+        cloudLinkedWorker?.reportResult
+      );
+      process2.stdout.write(`Cloud worker completed ${completed} job(s).
+`);
+      return 0;
+    } finally {
+      await closeCloudLinkedWorkerSync(cloudLinkedWorker);
+    }
+  }
   const controller = new AbortController();
   process2.on("SIGINT", () => controller.abort());
   process2.on("SIGTERM", () => controller.abort());
-  await startPolling(config, adapters, controller.signal);
-  return 0;
+  cloudLinkedWorker?.synchronizer.start();
+  try {
+    await startPolling(
+      config,
+      adapters,
+      controller.signal,
+      configPath && storePath ? (job) => verifyLocalWritebackAuthority(job, configPath, storePath, { cloudApproved: true }) : void 0,
+      cloudLinkedWorker?.reportResult
+    );
+    return 0;
+  } finally {
+    await closeCloudLinkedWorkerSync(cloudLinkedWorker);
+  }
+}
+function createCloudLinkedWorkerSync(configPath, storePath) {
+  const runtimeConfig = loadRuntimeConfigFromFile(configPath);
+  if (runtimeConfig.governance?.mode !== "cloud_linked") return void 0;
+  const store = createDefaultRuntimeStore(runtimeConfig, process2.env, storePath);
+  const synchronizer = new CloudLinkedSynchronizer(runtimeConfig, store, process2.env);
+  const reportResult = async ({ job, result, leaseId }) => {
+    const outboxItem = await enqueueCloudLinkedResult({
+      config: runtimeConfig,
+      store,
+      proposalId: job.proposal_id,
+      result,
+      leaseId
+    });
+    if (outboxItem) await synchronizer.flushEvent(outboxItem.event_id);
+  };
+  return { runtimeConfig, store, synchronizer, reportResult };
+}
+async function closeCloudLinkedWorkerSync(sync) {
+  if (!sync) return;
+  await sync.synchronizer.stop();
+  await sync.store.close();
 }
 async function up(args = []) {
   const allowed = /* @__PURE__ */ new Set([
@@ -46135,10 +48089,295 @@ async function runnerCommand(args) {
 async function cloud(args) {
   const [subcommand, ...rest] = args;
   if (subcommand === "connect") return cloudConnect(rest);
+  if (subcommand === "sync") return cloudSync(rest);
+  if (subcommand === "sync-activity") return cloudSyncActivity(rest);
   if (subcommand === "push") return cloudPush(rest);
+  if (subcommand === "outbox") return cloudOutbox(rest);
   usage();
   return 2;
 }
+async function cloudOutbox(args) {
+  const [action = "status", ...rest] = args;
+  const configPath = optionalArg(rest, "--config") ?? "synapsor.runner.json";
+  const storePath = optionalArg(rest, "--store") ?? process2.env.SYNAPSOR_LOCAL_STORE ?? "./.synapsor/local.db";
+  const runtimeConfig = loadRuntimeConfigFromFile(configPath);
+  if (runtimeConfig.governance?.mode !== "cloud_linked") throw new Error("cloud outbox requires governance.mode cloud_linked");
+  const store = createDefaultRuntimeStore(runtimeConfig, process2.env, storePath);
+  const synchronizer = new CloudLinkedSynchronizer(runtimeConfig, store, process2.env);
+  try {
+    if (action === "status") {
+      const status = await synchronizer.status();
+      if (rest.includes("--json")) process2.stdout.write(`${JSON.stringify({ ok: true, ...status }, null, 2)}
+`);
+      else process2.stdout.write([
+        "Synapsor Cloud outbox",
+        `Authority: ${status.authority_mode}`,
+        `Evidence residency: ${status.evidence_residency}`,
+        `Pending: ${status.pending}`,
+        `Leased: ${status.leased}`,
+        `Acknowledged: ${status.acknowledged}`,
+        `Dead letter: ${status.dead_letter}`,
+        `Reconciliation required: ${status.reconciliation_required}`,
+        status.last_reconciliation_error_code ? `Last reconciliation error: ${status.last_reconciliation_error_code}` : ""
+      ].filter(Boolean).join("\n") + "\n");
+      return 0;
+    }
+    if (action === "inspect") {
+      const requested = firstPositional(rest);
+      const entries = await store.listCloudOutbox?.({ limit: 1e4 }) ?? [];
+      const selected = requested === "latest" || !requested ? entries.at(-1) : entries.find((entry) => entry.event_id === requested);
+      if (!selected) throw new Error(`cloud outbox event not found: ${requested || "latest"}`);
+      const governance = selected.proposal_id ? await store.listCloudGovernanceEvents?.(selected.proposal_id) ?? [] : [];
+      const safe = { ok: true, outbox: selected, governance };
+      if (rest.includes("--json")) process2.stdout.write(`${JSON.stringify(safe, null, 2)}
+`);
+      else process2.stdout.write(`Cloud outbox event: ${selected.event_id}
+Status: ${selected.status}
+Kind: ${selected.kind}
+Attempts: ${selected.attempts}/${selected.max_attempts}
+Last error: ${selected.last_error_code ?? "none"}
+Governance events: ${governance.length}
+`);
+      return 0;
+    }
+    if (action === "reconcile") {
+      if (!rest.includes("--yes")) throw new Error("cloud outbox reconcile requires --yes after inspecting local and Cloud state");
+      const drained = await synchronizer.drainOnce();
+      const reconciled = await synchronizer.reconcileOnce();
+      const status = await synchronizer.status();
+      const result = { ok: true, drained, reconciled, status };
+      if (rest.includes("--json")) process2.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      else process2.stdout.write(`Cloud outbox reconciliation complete.
+Acknowledged: ${drained.acknowledged}
+Failed: ${drained.failed}
+Governance updates: ${reconciled.recorded}
+`);
+      return status.dead_letter || status.reconciliation_required ? 1 : 0;
+    }
+    if (action === "retry") {
+      const eventId = firstPositional(rest);
+      if (!eventId) throw new Error("cloud outbox retry requires <event-id>");
+      if (!rest.includes("--yes")) throw new Error("cloud outbox retry requires --yes after resolving the reported permanent cause");
+      if (!store.requeueCloudOutbox) throw new Error("configured runtime store does not support Cloud outbox repair");
+      const requeued = await store.requeueCloudOutbox(eventId);
+      const drained = await synchronizer.drainOnce();
+      const result = { ok: true, requeued, drained, status: await synchronizer.status() };
+      if (rest.includes("--json")) process2.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      else process2.stdout.write(`Requeued ${eventId}.
+Acknowledged: ${drained.acknowledged}
+Failed: ${drained.failed}
+`);
+      return drained.failed ? 1 : 0;
+    }
+    throw new Error("cloud outbox supports status, inspect, reconcile, and retry");
+  } finally {
+    await synchronizer.stop();
+    await store.close();
+  }
+}
+async function loadCloudConnection(configPath) {
+  const parsed = JSON.parse(await fs8.readFile(configPath, "utf8"));
+  if (!parsed.cloud) throw new Error(`cloud config missing in ${configPath}`);
+  const baseUrlEnv = parsed.cloud.base_url_env || "SYNAPSOR_CLOUD_BASE_URL";
+  const tokenEnv = parsed.cloud.runner_token_env || "SYNAPSOR_RUNNER_TOKEN";
+  const baseUrl = envValue2(process2.env, baseUrlEnv) || String(parsed.cloud.base_url || "").trim();
+  const runnerToken = envValue2(process2.env, tokenEnv);
+  const missing = [baseUrl ? "" : baseUrlEnv, runnerToken ? "" : tokenEnv].filter(Boolean);
+  if (missing.length > 0) throw new Error(`missing environment variables: ${missing.join(", ")}`);
+  const sourceId = String(parsed.cloud.source_id || process2.env.SYNAPSOR_SOURCE_ID || "").trim();
+  if (!sourceId || sourceId === "src_replace_me") throw new Error("cloud.source_id is required and must match the scoped Cloud Runner token source");
+  return {
+    file: parsed.cloud,
+    baseUrl,
+    runnerToken,
+    sourceId,
+    runnerId: String(parsed.cloud.runner_id || process2.env.SYNAPSOR_RUNNER_ID || "synapsor_runner_local").trim(),
+    runnerVersion: String(parsed.cloud.runner_version || process2.env.npm_package_version || package_default.version).trim()
+  };
+}
+function stripPrincipalScopeFromCloudRows(changeSet, column) {
+  const stripRecord = (value) => {
+    if (isRecord9(value)) delete value[column];
+  };
+  stripRecord(changeSet.before);
+  stripRecord(changeSet.after);
+  if ("frozen_set" in changeSet && isRecord9(changeSet.frozen_set) && Array.isArray(changeSet.frozen_set.members)) {
+    for (const member of changeSet.frozen_set.members) {
+      if (!isRecord9(member)) continue;
+      stripRecord(member.before);
+      stripRecord(member.after);
+    }
+  }
+  if (changeSet.schema_version === protocolVersions.compensationChangeSet) {
+    for (const member of changeSet.compensation.descriptor.members) {
+      stripRecord(member.expected_state);
+      stripRecord(member.restore_values);
+    }
+  }
+}
+async function cloudSync(args) {
+  const configPath = optionalArg(args, "--config") ?? "synapsor.cloud.json";
+  const storePath = optionalArg(args, "--store") ?? process2.env.SYNAPSOR_LOCAL_STORE ?? "./.synapsor/local.db";
+  const requested = firstPositional(args);
+  const connection = await loadCloudConnection(configPath);
+  const contractId = String(connection.file.contract_id || "").trim();
+  const contractVersionId = String(connection.file.contract_version_id || "").trim();
+  const contractDigest = String(connection.file.contract_digest || "").trim();
+  const runnerSourceId = String(connection.file.runner_source_id || connection.sourceId).trim();
+  if (!contractId || !contractVersionId || !/^sha256:[0-9a-f]{16,}$/i.test(contractDigest)) {
+    throw new Error("cloud sync requires contract_id, contract_version_id, and contract_digest in synapsor.cloud.json");
+  }
+  const client = new ControlPlaneClient({
+    baseUrl: connection.baseUrl,
+    runnerToken: connection.runnerToken,
+    sourceId: connection.sourceId,
+    runnerId: connection.runnerId
+  });
+  const store = new ProposalStore(storePath);
+  try {
+    const candidates = store.listProposals({ state: "pending_review", source: runnerSourceId, limit: 100 });
+    const selected = requested ? [requested === "latest" ? candidates[0] : store.getProposal(requested)].filter((value) => value !== void 0) : candidates;
+    if (requested && selected.length === 0) throw new Error(`local pending proposal not found: ${requested}`);
+    let synced = 0;
+    for (const proposal of selected) {
+      if (proposal.state !== "pending_review") throw new Error(`proposal ${proposal.proposal_id} is ${proposal.state}; only pending_review proposals can enter Cloud approval`);
+      if (proposal.source_id !== runnerSourceId) {
+        throw new Error(`proposal ${proposal.proposal_id} uses local source ${proposal.source_id}; Cloud source ${connection.sourceId} is mapped to reviewed local source ${runnerSourceId}`);
+      }
+      const evidence2 = store.listEvidenceBundles({ proposal: proposal.proposal_id, limit: 100 });
+      const queryAudit2 = store.listQueryAudit({ proposal: proposal.proposal_id, limit: 100 });
+      const sanitizedChangeSet = JSON.parse(JSON.stringify(proposal.change_set));
+      sanitizedChangeSet.evidence.items = [];
+      if (sanitizedChangeSet.guards.principal_scope) {
+        stripPrincipalScopeFromCloudRows(sanitizedChangeSet, sanitizedChangeSet.guards.principal_scope.column);
+        sanitizedChangeSet.principal.id = sanitizedChangeSet.guards.principal_scope.value_fingerprint;
+        delete sanitizedChangeSet.guards.principal_scope.value;
+      }
+      const payload = {
+        schema_version: protocolVersions.runnerProposal,
+        runner_id: connection.runnerId,
+        source_id: connection.sourceId,
+        ...connection.file.mapping_id ? { mapping_id: connection.file.mapping_id } : {},
+        contract: {
+          contract_id: contractId,
+          contract_version_id: contractVersionId,
+          digest: contractDigest
+        },
+        change_set: sanitizedChangeSet,
+        evidence_metadata: {
+          bundle_ids: evidence2.map((item) => item.evidence_bundle_id),
+          count: evidence2.length,
+          query_fingerprints: [...new Set(evidence2.map((item) => item.query_fingerprint).filter(Boolean))],
+          payload_uploaded: false
+        },
+        query_audit: {
+          audit_ids: queryAudit2.map((item) => item.audit_id).filter((value) => value !== void 0),
+          count: queryAudit2.length,
+          query_fingerprints: [...new Set(queryAudit2.map((item) => item.query_fingerprint).filter(Boolean))],
+          tables: [...new Set(queryAudit2.map((item) => item.table_name).filter(Boolean))],
+          payload_uploaded: false
+        }
+      };
+      await client.submitProposal(payload);
+      synced += 1;
+    }
+    if (args.includes("--json")) {
+      process2.stdout.write(`${JSON.stringify({ ok: true, synced, source_id: connection.sourceId, contract_version_id: contractVersionId }, null, 2)}
+`);
+    } else {
+      process2.stdout.write(`Synced ${synced} pending proposal${synced === 1 ? "" : "s"} to Cloud for ${connection.sourceId}.
+`);
+      process2.stdout.write("Only proposal diffs and bounded evidence/query-audit metadata were sent; database credentials and source rows stayed local.\n");
+    }
+    return 0;
+  } finally {
+    store.close();
+  }
+}
+async function cloudSyncActivity(args) {
+  const configPath = optionalArg(args, "--config") ?? "synapsor.cloud.json";
+  const storePath = optionalArg(args, "--store") ?? process2.env.SYNAPSOR_LOCAL_STORE ?? "./.synapsor/local.db";
+  const requested = firstPositional(args) ?? "latest";
+  const connection = await loadCloudConnection(configPath);
+  const runnerSourceId = String(connection.file.runner_source_id || connection.sourceId).trim();
+  const client = new ControlPlaneClient({
+    baseUrl: connection.baseUrl,
+    runnerToken: connection.runnerToken,
+    sourceId: connection.sourceId,
+    runnerId: connection.runnerId
+  });
+  const store = new ProposalStore(storePath);
+  try {
+    const proposal = requested === "latest" ? store.listProposals({ source: runnerSourceId, limit: 1 })[0] : store.getProposal(requested);
+    if (!proposal) throw new Error(`local proposal not found: ${requested}`);
+    if (proposal.source_id !== runnerSourceId) {
+      throw new Error(`proposal ${proposal.proposal_id} uses local source ${proposal.source_id}; Cloud source ${connection.sourceId} is mapped to reviewed local source ${runnerSourceId}`);
+    }
+    const evidence2 = store.listEvidenceBundles({ proposal: proposal.proposal_id, limit: 100 });
+    const queryAudit2 = store.listQueryAudit({ proposal: proposal.proposal_id, limit: 100 });
+    const replay2 = store.replay(proposal.proposal_id);
+    const principalScope3 = proposal.change_set.guards.principal_scope;
+    const common = {
+      schema_version: protocolVersions.runnerActivity,
+      runner_id: connection.runnerId,
+      source_id: connection.sourceId,
+      proposal_id: proposal.proposal_id,
+      capability: proposal.action,
+      tenant_id: proposal.tenant_id,
+      principal: principalScope3?.value_fingerprint ?? proposal.principal,
+      business_object: proposal.business_object,
+      object_id: proposal.object_id,
+      status: proposal.state
+    };
+    const events2 = [
+      ...evidence2.map((item) => ({
+        ...common,
+        event_id: `evidence:${item.evidence_bundle_id}`,
+        event_type: "evidence.recorded",
+        evidence_ids: [item.evidence_bundle_id],
+        detail: { stored_locally: true, payload_uploaded: false },
+        occurred_at: item.created_at
+      })),
+      ...queryAudit2.map((item) => ({
+        ...common,
+        event_id: `query-audit:${String(item.audit_id)}`,
+        event_type: "query_audit.recorded",
+        query_audit_ids: [String(item.audit_id)],
+        ...typeof item.evidence_bundle_id === "string" ? { evidence_ids: [item.evidence_bundle_id] } : {},
+        detail: { stored_locally: true, payload_uploaded: false },
+        occurred_at: typeof item.created_at === "string" ? item.created_at : void 0
+      })),
+      {
+        ...common,
+        event_id: `replay:${replay2.replay_id}`,
+        event_type: "replay.recorded",
+        replay_id: replay2.replay_id,
+        detail: { stored_locally: true, payload_uploaded: false }
+      }
+    ];
+    for (const event of events2) await client.submitActivity(event);
+    const output = {
+      ok: true,
+      synced: events2.length,
+      proposal_id: proposal.proposal_id,
+      evidence_references: evidence2.length,
+      query_audit_references: queryAudit2.length,
+      replay_id: replay2.replay_id
+    };
+    if (args.includes("--json")) process2.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+    else {
+      process2.stdout.write(`Synced ${events2.length} local activity reference${events2.length === 1 ? "" : "s"} to Cloud for ${proposal.proposal_id}.
+`);
+      process2.stdout.write("Evidence contents, source rows, database credentials, and local replay payloads stayed local.\n");
+    }
+    return 0;
+  } finally {
+    store.close();
+  }
+}
 async function cloudPush(args) {
   const target2 = firstPositional(args);
   if (!target2) throw new Error("cloud push requires <synapsor.contract.json>");
@@ -46192,20 +48431,46 @@ async function cloudPush(args) {
     return 0;
   }
   const apiUrl = (optionalArg(args, "--api-url") ?? process2.env.SYNAPSOR_CLOUD_BASE_URL ?? "").trim();
-  const token = (optionalArg(args, "--token") ?? process2.env.SYNAPSOR_CLOUD_TOKEN ?? process2.env.SYNAPSOR_RUNNER_TOKEN ?? "").trim();
+  if (args.includes("--token")) {
+    throw new Error("cloud push does not accept secrets through --token. Set SYNAPSOR_API_KEY for automation or SYNAPSOR_CLOUD_ACCESS_TOKEN for an authenticated human session.");
+  }
+  const apiKey = (process2.env.SYNAPSOR_API_KEY ?? "").trim();
+  const humanAccessToken = (process2.env.SYNAPSOR_CLOUD_ACCESS_TOKEN ?? "").trim();
+  const credential = apiKey || humanAccessToken;
   if (!workspace) {
     throw new Error("cloud push upload requires --workspace <project_id> or SYNAPSOR_CLOUD_WORKSPACE/SYNAPSOR_WORKSPACE_ID/SYNAPSOR_PROJECT_ID.");
   }
-  if (!apiUrl || !token) {
-    throw new Error("cloud push upload requires --api-url plus --token/SYNAPSOR_CLOUD_TOKEN. Use --dry-run for local validation without a network call.");
+  if (!apiUrl || !credential) {
+    throw new Error("cloud push upload requires --api-url/SYNAPSOR_CLOUD_BASE_URL plus SYNAPSOR_API_KEY or SYNAPSOR_CLOUD_ACCESS_TOKEN. Use --dry-run for local validation without a network call.");
+  }
+  let response;
+  try {
+    response = await new CloudControlClient({
+      baseUrl: apiUrl,
+      credential,
+      credentialKind: apiKey ? "service" : "human",
+      userAgent: "synapsor-runner-cloud-push"
+    }).pushContract({
+      projectId: workspace,
+      contract,
+      name,
+      description,
+      source: "runner",
+      sourceVersions: payload.source_versions,
+      activate: args.includes("--activate"),
+      idempotencyKey
+    });
+  } catch (error) {
+    if (error instanceof CloudControlError) {
+      const request = error.request_id ? ` Request: ${error.request_id}.` : "";
+      const issues = Array.isArray(error.details?.errors) ? error.details.errors.slice(0, 3).map((issue) => isRecord9(issue) ? `${String(issue.path || "$")} ${String(issue.code || "validation_error")}: ${String(issue.message || "")}` : String(issue)).join("; ") : "";
+      if (error.status === 422 && issues) {
+        throw new Error(`Cloud rejected the contract: ${issues}.${request}`);
+      }
+      throw new Error(`cloud push upload failed: ${error.message} (${error.error_code}).${issues ? ` ${issues}` : ""}${request}`);
+    }
+    throw error;
   }
-  const response = await postCloudContractPush({
-    apiUrl,
-    token,
-    workspace,
-    payload,
-    idempotencyKey
-  });
   if (json) {
     process2.stdout.write(`${JSON.stringify(response, null, 2)}
 `);
@@ -46245,133 +48510,51 @@ function contractSummary(contract) {
     kept_out_fields: keptOutFields.size
   };
 }
-async function postCloudContractPush(input) {
-  let endpoint;
-  try {
-    endpoint = new URL(`/v1/control/projects/${encodeURIComponent(input.workspace)}/agent-contracts`, input.apiUrl.endsWith("/") ? input.apiUrl : `${input.apiUrl}/`);
-  } catch {
-    throw new Error("cloud push upload failed: --api-url/SYNAPSOR_CLOUD_BASE_URL is not a valid URL.");
-  }
-  const headers = {
-    accept: "application/json",
-    authorization: `Bearer ${input.token}`,
-    "content-type": "application/json",
-    "user-agent": "synapsor-runner-cloud-push"
-  };
-  if (input.idempotencyKey) headers["idempotency-key"] = input.idempotencyKey;
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 15e3);
-  let response;
-  try {
-    response = await fetch(endpoint, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(input.payload),
-      signal: controller.signal
-    });
-  } catch (error) {
-    const reason = error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError") ? "request timed out" : "network request failed";
-    throw new Error(`cloud push upload failed: ${reason}. Check --api-url/SYNAPSOR_CLOUD_BASE_URL and network connectivity.`);
-  } finally {
-    clearTimeout(timeout);
-  }
-  const text = await response.text();
-  const body = parseCloudResponseJson(text);
-  if (!response.ok || body.ok === false) {
-    throw new Error(cloudPushErrorMessage(response.status, body));
-  }
-  return body;
-}
-function parseCloudResponseJson(text) {
-  if (!text.trim()) return {};
-  try {
-    const parsed = JSON.parse(text);
-    return isRecord9(parsed) ? parsed : { value: parsed };
-  } catch {
-    return { raw: text.slice(0, 500) };
-  }
-}
-function cloudPushErrorMessage(status, body) {
-  const code = typeof body.error === "string" && body.error ? body.error : `http_${status}`;
-  const detail = cloudValidationDetail(body);
-  if (status === 401) return `cloud push upload failed: token is missing, invalid, or expired (${code}).`;
-  if (status === 403) return `cloud push upload failed: token does not have permission to write this workspace (${code}).`;
-  if (status === 404) return `cloud push upload failed: Cloud API URL or workspace was not found (${code}).`;
-  if (status === 409) return `cloud push upload failed: registry conflict (${code}).${detail}`;
-  if (status === 422) return `cloud push upload failed: Cloud rejected the contract (${code}).${detail}`;
-  if (status >= 500) return `cloud push upload failed: Cloud returned HTTP ${status} (${code}).`;
-  return `cloud push upload failed: Cloud returned HTTP ${status} (${code}).${detail}`;
-}
-function cloudValidationDetail(body) {
-  const errors = Array.isArray(body.errors) ? body.errors : [];
-  if (!errors.length) {
-    const message2 = typeof body.message === "string" ? body.message : "";
-    return message2 ? ` ${message2}` : "";
-  }
-  const rendered = errors.slice(0, 3).map((issue) => {
-    if (!isRecord9(issue)) return String(issue);
-    const path9 = typeof issue.path === "string" ? issue.path : "$";
-    const code = typeof issue.code === "string" ? issue.code : "validation_error";
-    const message2 = typeof issue.message === "string" ? issue.message : "";
-    return `${path9} ${code}${message2 ? `: ${message2}` : ""}`;
-  }).join("; ");
-  return ` ${rendered}`;
-}
 function cloudStringField(value, key) {
   return isRecord9(value) && typeof value[key] === "string" ? value[key] : "";
 }
 async function cloudConnect(args) {
   const configPath = optionalArg(args, "--config") ?? process2.env.SYNAPSOR_MCP_CONFIG ?? "synapsor.cloud.json";
-  const parsed = JSON.parse(await fs8.readFile(configPath, "utf8"));
-  if (!parsed.cloud) {
-    process2.stdout.write(`cloud config missing in ${configPath}
-`);
-    return 1;
-  }
-  const baseUrlEnv = parsed.cloud.base_url_env || "SYNAPSOR_CLOUD_BASE_URL";
-  const tokenEnv = parsed.cloud.runner_token_env || "SYNAPSOR_RUNNER_TOKEN";
-  const baseUrl = envValue2(process2.env, baseUrlEnv);
-  const runnerToken = envValue2(process2.env, tokenEnv);
-  const missing = [baseUrl ? "" : baseUrlEnv, runnerToken ? "" : tokenEnv].filter(Boolean);
-  if (missing.length > 0) {
-    process2.stdout.write(`missing environment variables: ${missing.join(", ")}
+  let connection;
+  try {
+    connection = await loadCloudConnection(configPath);
+  } catch (error) {
+    process2.stdout.write(`${error instanceof Error ? error.message : String(error)}
 `);
     return 1;
   }
-  if (!baseUrl || !runnerToken) {
-    process2.stdout.write("missing Cloud connection settings\n");
-    return 1;
-  }
-  const sourceId = String(parsed.cloud.source_id || process2.env.SYNAPSOR_SOURCE_ID || "").trim();
-  if (!sourceId || sourceId === "src_replace_me") {
-    process2.stdout.write("cloud.source_id is required before registering a runner. It must match the scoped Cloud runner token source.\n");
-    return 1;
-  }
-  const runnerId = String(parsed.cloud.runner_id || process2.env.SYNAPSOR_RUNNER_ID || "synapsor_runner_local").trim();
-  const runnerVersion = String(parsed.cloud.runner_version || process2.env.npm_package_version || "0.1.0").trim();
-  const engines = normalizeEngines(parsed.cloud.engines);
-  const capabilities = normalizeCapabilities(parsed.cloud.capabilities);
+  const { baseUrl, runnerToken, sourceId, runnerId, runnerVersion } = connection;
+  const engines = normalizeEngines(connection.file.engines);
+  const capabilities = normalizeCapabilities(connection.file.capabilities);
   const client = new ControlPlaneClient({
     baseUrl,
     runnerToken,
-    sourceId
+    sourceId,
+    runnerId
   });
   const report = await client.doctor();
-  if (!report.ok) {
-    process2.stdout.write(`cloud connection failed: status ${report.status}
+  if (!report.ok || !report.authenticated) {
+    const reason = report.authenticated ? `status ${report.status}` : "the endpoint did not authenticate the Runner protocol; upgrade Cloud or use its supported API URL";
+    process2.stdout.write(`cloud connection failed: ${reason}
 `);
     return 1;
   }
   const registration = {
     schema_version: protocolVersions.runnerRegistration,
+    protocol_version: protocolVersions.runnerControl,
     runner_id: runnerId,
     runner_version: runnerVersion,
     engines,
     capabilities,
     scope: {
-      project_id: String(parsed.cloud.project_id || "token_scope"),
+      project_id: String(connection.file.project_id || "token_scope"),
       source_ids: [sourceId]
     },
+    contracts: connection.file.contract_id && connection.file.contract_version_id && connection.file.contract_digest ? [{
+      contract_id: connection.file.contract_id,
+      contract_version_id: connection.file.contract_version_id,
+      digest: connection.file.contract_digest
+    }] : void 0,
     registered_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   await client.register(registration);
@@ -48022,6 +50205,11 @@ Run ${cliCommandName()} onboard db --from-env DATABASE_URL, or pass --config <pa
     const autoApprovalDisabled = parsed.approvals?.disable_auto_approval === true;
     const approvalPolicies = approvalPolicySummaries(parsed);
     const capabilityDetails = toolPreviewCapabilityDetails(parsed);
+    const cloudSync2 = await runtime.cloudSyncStatus();
+    const governance = {
+      ...cloudSync2,
+      queue_when_unavailable: parsed.governance?.mode === "cloud_linked" && parsed.governance.queue_when_unavailable !== false
+    };
     const graduatedTrust = {
       enabled: parsed.graduated_trust?.enabled === true,
       kill_switch: parsed.graduated_trust?.kill_switch === true,
@@ -48041,7 +50229,7 @@ Run ${cliCommandName()} onboard db --from-env DATABASE_URL, or pass --config <pa
       { name: "write credentials absent", ok: !/(password|secret|bearer|private[_-]?key|token)/i.test(serialized), detail: "MCP tools do not include write credentials" }
     ];
     const ok = checks.every((check) => check.ok);
-    return { ok, configPath, storePath, aliasMode, names, exposures, autoApprovalDisabled, approvalPolicies, capabilityDetails, graduatedTrust, checks };
+    return { ok, configPath, storePath, aliasMode, names, exposures, autoApprovalDisabled, approvalPolicies, capabilityDetails, governance, graduatedTrust, checks };
   } finally {
     await runtime.close();
   }
@@ -48065,6 +50253,9 @@ function formatToolsPreview(input) {
     `Config: ${input.configPath}`,
     `Store: ${input.storePath}`,
     `Alias mode: ${input.aliasMode}`,
+    `Governance authority: ${input.governance.authority_mode}`,
+    `Evidence residency: ${input.governance.evidence_residency}`,
+    ...input.governance.authority_mode === "cloud_linked" ? [`Queue proposals while Cloud is unavailable: ${input.governance.queue_when_unavailable ? "yes" : "no"}`] : [],
     `auto-approval: ${input.autoApprovalDisabled ? "disabled" : "enabled"}`,
     `graduated trust: ${input.graduatedTrust.enabled ? input.graduatedTrust.kill_switch ? "enabled, kill switch active" : `enabled (${input.graduatedTrust.criteria} reviewed criteria)` : "disabled"}; operator-only, never MCP-facing`,
     ...formatApprovalPolicyPreview(input.approvalPolicies),
@@ -48102,6 +50293,9 @@ function toolPreviewCapabilityDetails(config) {
       cardinality,
       target: `${capability.target.schema}.${capability.target.table}`,
       tenant_source: capability.target.single_tenant_dev ? "explicit single-tenant development acknowledgement" : `${capability.target.tenant_key ?? "missing tenant key"} from trusted ${context?.provider ?? "context"}`,
+      ...capability.target.principal_scope_key ? {
+        principal_source: `${capability.target.principal_scope_key} from required trusted ${context?.provider ?? "context"} binding ${context?.principal_binding ?? "principal"}`
+      } : {},
       writable_columns: capability.allowed_columns ?? [],
       dedup_columns: capability.operation?.deduplication?.components.map((component) => component.column) ?? [],
       fixed_selection: (capability.operation?.selection?.all ?? capability.aggregate?.selection?.all)?.map((term) => `${term.column} ${term.operator} ${formatScalar(term.value)}`) ?? [],
@@ -48123,6 +50317,7 @@ function formatToolPreviewCapabilityDetails(details) {
     `  - ${detail.name}: ${detail.kind}${detail.operation ? ` ${detail.cardinality === "set" ? "BOUNDED SET " : "SINGLE-ROW "}${detail.operation.toUpperCase()}` : ""}`,
     detail.kind === "aggregate_read" ? `    target: ${detail.target}; output: one ${detail.aggregate} scalar; minimum group size: ${detail.minimum_group_size}` : `    target: ${detail.target}; max rows: ${detail.max_rows}`,
     `    tenant: ${detail.tenant_source}`,
+    ...detail.principal_source ? [`    principal row lock: ${detail.principal_source} (AND tenant)`] : [],
     ...detail.kind === "aggregate_read" ? [
       `    fixed selection: ${detail.fixed_selection.join(" AND ") || "tenant scope only"}`,
       "    privacy: member rows and identities are never returned or stored as evidence items"
@@ -49318,6 +51513,7 @@ async function proposalsApprove(args) {
   const storePath = localStorePath(args);
   const configPath = optionalArg(args, "--config") ?? "synapsor.runner.json";
   const config = await optionalRuntimeConfig(configPath);
+  assertLocalGovernanceMutationAllowed(config, "proposals approve");
   if (config && runtimeStoreBridgeRequired(args, config)) {
     return withSharedPostgresRuntimeStoreBridge(args, config, `proposals approve ${proposalId}`, (bridgeStorePath) => proposalsApprove(argsWithRuntimeStoreBridge(args, bridgeStorePath)));
   }
@@ -49373,6 +51569,7 @@ async function proposalsReject(args) {
   const storePath = localStorePath(args);
   const configPath = optionalArg(args, "--config") ?? "synapsor.runner.json";
   const config = await optionalRuntimeConfig(configPath);
+  assertLocalGovernanceMutationAllowed(config, "proposals reject");
   if (config && runtimeStoreBridgeRequired(args, config)) {
     return withSharedPostgresRuntimeStoreBridge(args, config, `proposals reject ${proposalId}`, (bridgeStorePath) => proposalsReject(argsWithRuntimeStoreBridge(args, bridgeStorePath)));
   }
@@ -50243,6 +52440,10 @@ function assertNoRuntimeStoreForLocalMutation(config, command, args = []) {
   if (args.includes(runtimeStoreBridgeFlag)) return;
   throw new Error(`${command} cannot run directly against the local SQLite path when storage.shared_postgres.mode=runtime_store. Use the built-in runtime-store bridge or switch to local SQLite/mirror mode.`);
 }
+function assertLocalGovernanceMutationAllowed(config, command) {
+  if (config?.governance?.mode !== "cloud_linked") return;
+  throw new Error(`${command} is disabled for cloud_linked governance. Record human decisions through Synapsor Cloud; only a Cloud-approved leased job may reach the trusted Runner writeback path.`);
+}
 function runtimeStoreBridgeRequired(args, config) {
   return config?.storage?.shared_postgres?.mode === "runtime_store" && !args.includes(runtimeStoreBridgeFlag);
 }
@@ -52641,9 +54842,14 @@ instead of being ignored.
 `,
     cloud: `Usage:
   ${cmd} cloud connect --config ./synapsor.cloud.json
+  ${cmd} cloud sync latest --config ./synapsor.cloud.json --store ./.synapsor/local.db
+  ${cmd} cloud sync-activity latest --config ./synapsor.cloud.json --store ./.synapsor/local.db
   ${cmd} cloud push ./synapsor.contract.json --dry-run [--workspace <id>] [--name <registry-name>]
 
-cloud push validates and normalizes the contract locally, then prints the
+cloud sync sends a pending proposal plus bounded evidence/query-audit metadata.
+cloud sync-activity sends stable local evidence, query-audit, and replay ids;
+record contents and database credentials stay local. cloud push validates and
+normalizes the contract locally, then prints the
 payload summary. With --dry-run it makes no network request. Without --dry-run
 it uploads to the authenticated Cloud registry and reports the stored contract,
 version, digest, and registry URL returned by the server.
@@ -52674,6 +54880,7 @@ Options:
     start: `Usage:
   ${cmd} start --from-env DATABASE_URL [--schema public] [--mode read_only|shadow|review]
   ${cmd} start --from-env DATABASE_URL --mode review --writeback http_handler --handler-url-env APP_WRITEBACK_URL [--handler-signing-secret-env APP_WRITEBACK_SIGNING_SECRET]
+  ${cmd} runner start --once --config ./synapsor.runner.json --store ./.synapsor/local.db
   ${cmd} start
 
 With --from-env, run the guided own-database setup: inspect schema, choose one
@@ -52682,7 +54889,9 @@ call, and print MCP/UI next steps.
 
 With no flags, start the legacy cloud-linked writeback polling worker from the
 worker environment config. Prefer \`${cmd} runner start\` for that worker path
-so it is not confused with first-run onboarding.
+so it is not confused with first-run onboarding. Add \`--once\` with both
+\`--config\` and \`--store\` for a bounded claim/apply cycle that still rechecks
+the local reviewed contract and proposal before writeback.
 `,
     inspect: `Usage:
   ${cmd} inspect --from-env DATABASE_URL [--engine auto|postgres|mysql] [--schema public] [--json]
@@ -53115,7 +55324,8 @@ export {
   reconciliationReceipt,
   reconciliationSupportedOutcome,
   resolveSqlWriteDatabaseUrl,
-  runInitWizard
+  runInitWizard,
+  verifyLocalWritebackAuthority
 };
 /*! Bundled license information: