@native-marketing/sdk 0.3.3 → 0.3.5

package/dist/index.js

@@ -549,6 +549,18 @@ var reviewContentAssetInputSchema = z9.object({
   decision: assetReviewDecisionSchema,
   note: z9.string().max(4096).nullable().optional().transform((value) => value ?? null)
 });
+var reviewAssetReadSchema = z9.object({
+  ref: z9.templateLiteral(["cf://asset/", uuidSchema])
+}).strict();
+var reviewAssetReadViewSchema = z9.object({
+  schemaVersion: z9.literal(1),
+  projectCode: z9.string().regex(/^PRJ-[0-9]{6,}$/),
+  resourceKind: z9.literal("ASSET"),
+  resourceRef: cfRefSchema,
+  record: contentAssetSchema,
+  recordSha256: z9.string().regex(/^[a-f0-9]{64}$/),
+  currentStateOnly: z9.literal(true)
+}).strict();
 
 // packages/contracts/src/media.ts
 import { z as z10 } from "zod";
@@ -5421,6 +5433,7 @@ var businessDocumentToolSchema = z72.enum([
   "cf_get_opportunity_plan",
   "cf_list_editorial_proposals",
   "cf_get_editorial_proposal",
+  "cf_get_review_asset",
   "cf_get_work_context",
   "cf_get_channel_catalog",
   "cf_get_strategy_preparation",
@@ -5558,6 +5571,7 @@ var agentSummarySourceSchema = z73.enum([
   "cf_get_opportunity",
   "cf_get_opportunity_plan",
   "cf_get_editorial_proposal",
+  "cf_get_review_asset",
   "cf_get_channel_catalog",
   "cf_get_strategy_preparation",
   "cf_get_workspace_progress",
@@ -5832,124 +5846,217 @@ var foundationDecisionReceiptSchema = z77.discriminatedUnion("state", [
   z77.object({ state: z77.literal("NOT_FOUND"), decision: z77.null() }).strict()
 ]);
 
-// packages/contracts/src/material-verification.ts
+// packages/contracts/src/knowledge-discovery.ts
+import { z as z79 } from "zod";
+
+// packages/contracts/src/foundation/command-outcome.ts
 import { z as z78 } from "zod";
-var hash4 = z78.string().regex(/^sha256:[a-f0-9]{64}$/);
-var materialVerificationStartSchema = z78.object({
-  requestId: z78.uuid(),
-  fullReadLimitBytes: z78.number().int().min(1).max(256 * 1024 * 1024).default(32 * 1024 * 1024)
-}).strict();
-var materialVerificationIdSchema = z78.object({ jobId: z78.uuid() }).strict();
-var materialVerificationReceiptSchema = z78.object({
-  original: z78.object({
-    state: z78.enum(["NOT_CHECKED", "VERIFIED_FULL", "UPSTREAM_VERIFIED", "FAILED"]),
+var commandRejectedReceiptSchema = z78.object({
+  state: z78.literal("REJECTED"),
+  result: z78.null(),
+  error: z78.object({
+    code: z78.string().regex(/^[A-Z0-9_]{1,100}$/),
+    outcome: z78.literal("REJECTED"),
+    recovery: z78.string().min(1).max(100)
+  }).strict()
+}).strict();
+
+// packages/contracts/src/knowledge-discovery.ts
+var knowledgeRemoteRefSchema = z79.string().min(1).max(4096).refine((value) => {
+  try {
+    const url = new URL(value);
+    return !url.username && !url.password && /^[a-z][a-z0-9+.-]*:$/.test(url.protocol);
+  } catch {
+    return false;
+  }
+});
+var knowledgeDiscoveryQuerySchema = z79.object({
+  q: z79.string().trim().min(2).max(160).optional(),
+  cursor: z79.string().min(1).max(8192).optional(),
+  resourceType: z79.string().regex(/^[a-z][a-z0-9._-]{0,63}$/).optional(),
+  limit: z79.number().int().min(1).max(50).default(20)
+}).strict();
+var knowledgeDiscoveryReadQuerySchema = z79.object({
+  ref: knowledgeRemoteRefSchema,
+  expectedContentHash: z79.string().regex(/^sha256:[a-f0-9]{64}$/).optional()
+}).strict();
+var knowledgeDiscoveryItemSchema = z79.object({
+  ref: knowledgeRemoteRefSchema,
+  ownerTenantId: z79.string().min(1).max(256),
+  resourceType: z79.string().min(1).max(128),
+  originType: z79.enum(["LEGACY_PROJECT", "TENANT_AUTHOR", "TENANT_SOURCE"]),
+  identityHash: z79.string().regex(/^sha256:[a-f0-9]{64}$/),
+  identityKind: z79.enum(["CAS_BYTES", "REFERENCE_RECORD_DIGEST"]),
+  kind: z79.string().min(1).max(128),
+  classification: z79.string().max(128),
+  mediaType: z79.string().min(1).max(256),
+  title: z79.string().max(512),
+  summary: z79.string().max(1024),
+  readable: z79.boolean(),
+  reasonCodes: z79.array(z79.string().max(128)).max(32)
+});
+var knowledgeDiscoveryPageSchema = z79.object({
+  schemaVersion: z79.literal(1),
+  sourceTenantId: z79.string().min(1).max(256),
+  items: z79.array(knowledgeDiscoveryItemSchema).max(50),
+  pageInfo: z79.object({ nextCursor: z79.string().max(8192).nullable() }).strict(),
+  coverage: z79.enum(["CURRENT_AUTHORIZED_DIRECTORY", "INDEXED_DESCRIPTIONS_ONLY"]),
+  checkedAt: z79.string().datetime()
+}).strict();
+var knowledgeDiscoveryReadSchema = z79.object({
+  schemaVersion: z79.literal(1),
+  sourceTenantId: z79.string().min(1).max(256),
+  item: knowledgeDiscoveryItemSchema,
+  contentHash: z79.string().regex(/^sha256:[a-f0-9]{64}$/),
+  mediaType: z79.string().min(1).max(256),
+  byteLength: z79.number().int().min(0).max(524288),
+  content: z79.string().max(524288),
+  verified: z79.literal(true),
+  checkedAt: z79.string().datetime()
+}).strict();
+var knowledgeDiscoveryDescriptionSchema = z79.object({
+  schemaVersion: z79.literal(1),
+  sourceTenantId: z79.string().min(1).max(256),
+  item: knowledgeDiscoveryItemSchema,
+  byteLength: z79.number().int().nonnegative().safe().nullable(),
+  checkedAt: z79.string().datetime()
+}).strict();
+var knowledgeAdoptionCommandSchema = knowledgeDiscoveryReadQuerySchema.required().extend({
+  requestId: z79.string().min(1).max(128)
+}).strict();
+var knowledgeAdoptionResultSchema = z79.object({ result: sourceRefSchema, replayed: z79.boolean() }).strict();
+var knowledgeAdoptionReceiptQuerySchema = z79.object({ requestId: z79.string().min(1).max(128) }).strict();
+var knowledgeAdoptionReceiptSchema = z79.discriminatedUnion("state", [
+  z79.object({ state: z79.literal("FOUND"), result: sourceRefSchema }).strict(),
+  z79.object({ state: z79.literal("NOT_FOUND"), result: z79.null() }).strict(),
+  commandRejectedReceiptSchema
+]);
+var adoptedKnowledgeResourceSchema = z79.object({
+  schemaVersion: z79.literal(1),
+  sourceTenantId: z79.string().min(1).max(256),
+  ownerTenantId: z79.string().min(1).max(256).optional(),
+  ref: knowledgeRemoteRefSchema,
+  identityHash: z79.string().regex(/^sha256:[a-f0-9]{64}$/)
+}).strict();
+
+// packages/contracts/src/material-verification.ts
+import { z as z80 } from "zod";
+var hash4 = z80.string().regex(/^sha256:[a-f0-9]{64}$/);
+var materialVerificationStartSchema = z80.object({
+  requestId: z80.uuid(),
+  fullReadLimitBytes: z80.number().int().min(1).max(256 * 1024 * 1024).default(32 * 1024 * 1024)
+}).strict();
+var materialVerificationIdSchema = z80.object({ jobId: z80.uuid() }).strict();
+var materialVerificationReceiptSchema = z80.object({
+  original: z80.object({
+    state: z80.enum(["NOT_CHECKED", "VERIFIED_FULL", "UPSTREAM_VERIFIED", "FAILED"]),
     transportHash: hash4.nullable(),
-    byteLength: z78.number().int().nonnegative().nullable(),
-    reasonCode: z78.string().nullable()
+    byteLength: z80.number().int().nonnegative().nullable(),
+    reasonCode: z80.string().nullable()
   }),
-  projection: z78.object({
-    state: z78.enum(["NOT_CHECKED", "VERIFIED", "NOT_APPLICABLE", "UNAVAILABLE"]),
-    documentRef: z78.string().nullable(),
+  projection: z80.object({
+    state: z80.enum(["NOT_CHECKED", "VERIFIED", "NOT_APPLICABLE", "UNAVAILABLE"]),
+    documentRef: z80.string().nullable(),
     documentHash: hash4.nullable(),
-    reasonCode: z78.string().nullable()
+    reasonCode: z80.string().nullable()
   }),
-  media: z78.object({
-    state: z78.enum(["NOT_CHECKED", "PARTIAL", "COMPLETE", "NOT_APPLICABLE", "UNAVAILABLE"]),
-    documentRef: z78.string().nullable(),
+  media: z80.object({
+    state: z80.enum(["NOT_CHECKED", "PARTIAL", "COMPLETE", "NOT_APPLICABLE", "UNAVAILABLE"]),
+    documentRef: z80.string().nullable(),
     documentHash: hash4.nullable(),
-    afterOrdinal: z78.number().int().nonnegative().nullable(),
-    mirroredVerified: z78.number().int().nonnegative(),
-    remoteOnly: z78.number().int().nonnegative(),
-    unavailable: z78.number().int().nonnegative(),
-    reasonCode: z78.string().nullable()
+    afterOrdinal: z80.number().int().nonnegative().nullable(),
+    mirroredVerified: z80.number().int().nonnegative(),
+    remoteOnly: z80.number().int().nonnegative(),
+    unavailable: z80.number().int().nonnegative(),
+    reasonCode: z80.string().nullable()
   }),
-  checkedAt: z78.string().datetime(),
-  errorCode: z78.string().nullable(),
-  humanReading: z78.literal("NOT_PROVEN"),
-  agentReading: z78.literal("NOT_PROVEN")
-}).strict();
-var materialVerificationJobSchema = z78.object({
-  id: z78.uuid(),
-  tenantId: z78.uuid(),
-  kvTenantId: z78.string(),
-  projectKey: z78.string(),
-  connectorRevision: z78.string().nullable(),
-  generation: z78.number().int().positive(),
-  inventoryStatus: z78.enum(["IDLE", "RUNNING", "FAILED", "COMPLETE"]),
-  acknowledgedSeq: z78.number().int().nonnegative(),
-  pendingSeq: z78.number().int().nonnegative().nullable(),
-  fullReadLimitBytes: z78.number().int().positive(),
-  state: z78.enum(["READY", "RUNNING", "COMPLETE", "CANCELLED", "STALE"]),
-  total: z78.number().int().nonnegative(),
-  completed: z78.number().int().nonnegative(),
-  failed: z78.number().int().nonnegative(),
-  pending: z78.number().int().nonnegative(),
-  createdAt: z78.string().datetime(),
-  updatedAt: z78.string().datetime()
-}).strict();
-var materialVerificationItemSchema = z78.object({
-  sourceId: z78.uuid(),
-  artifactRef: z78.string(),
+  checkedAt: z80.string().datetime(),
+  errorCode: z80.string().nullable(),
+  humanReading: z80.literal("NOT_PROVEN"),
+  agentReading: z80.literal("NOT_PROVEN")
+}).strict();
+var materialVerificationJobSchema = z80.object({
+  id: z80.uuid(),
+  tenantId: z80.uuid(),
+  kvTenantId: z80.string(),
+  projectKey: z80.string(),
+  connectorRevision: z80.string().nullable(),
+  generation: z80.number().int().positive(),
+  inventoryStatus: z80.enum(["IDLE", "RUNNING", "FAILED", "COMPLETE"]),
+  acknowledgedSeq: z80.number().int().nonnegative(),
+  pendingSeq: z80.number().int().nonnegative().nullable(),
+  fullReadLimitBytes: z80.number().int().positive(),
+  state: z80.enum(["READY", "RUNNING", "COMPLETE", "CANCELLED", "STALE"]),
+  total: z80.number().int().nonnegative(),
+  completed: z80.number().int().nonnegative(),
+  failed: z80.number().int().nonnegative(),
+  pending: z80.number().int().nonnegative(),
+  createdAt: z80.string().datetime(),
+  updatedAt: z80.string().datetime()
+}).strict();
+var materialVerificationItemSchema = z80.object({
+  sourceId: z80.uuid(),
+  artifactRef: z80.string(),
   identityHash: hash4,
-  resourceType: z78.string(),
-  state: z78.enum(["PENDING", "COMPLETE", "FAILED"]),
+  resourceType: z80.string(),
+  state: z80.enum(["PENDING", "COMPLETE", "FAILED"]),
   receipt: materialVerificationReceiptSchema.nullable()
 }).strict();
-var materialVerificationPageSchema = z78.object({
+var materialVerificationPageSchema = z80.object({
   job: materialVerificationJobSchema,
-  items: z78.array(materialVerificationItemSchema).max(100),
-  nextAfter: z78.string().nullable()
+  items: z80.array(materialVerificationItemSchema).max(100),
+  nextAfter: z80.string().nullable()
 }).strict();
 
 // packages/contracts/src/editorial-workspace.ts
-import { z as z79 } from "zod";
-var sha = z79.string().regex(/^[a-f0-9]{64}$/u);
+import { z as z81 } from "zod";
+var sha = z81.string().regex(/^[a-f0-9]{64}$/u);
 var publicEditorialCandidateSchema = editorialCandidateSchema.omit({ projectId: true });
 var publicEditorialKernelSchema = contentKernelSchema.omit({ projectId: true });
-var editorialKindSchema = z79.enum(["CANDIDATE", "KERNEL"]);
-var command2 = z79.object({
-  version: z79.literal(1),
+var editorialKindSchema = z81.enum(["CANDIDATE", "KERNEL"]);
+var command2 = z81.object({
+  version: z81.literal(1),
   requestId: uuidSchema,
   expectedReviewSha256: sha,
-  note: z79.string().trim().max(4096).nullable()
+  note: z81.string().trim().max(4096).nullable()
 }).strict();
 var humanCandidateDecisionSchema = command2.extend({ decision: editorialDecisionSchema }).strict();
 var humanKernelReviewSchema = command2.extend({ decision: kernelReviewDecisionSchema }).strict();
-var editorialCandidateQuerySchema = z79.object({
-  limit: z79.coerce.number().int().min(1).max(100).default(20),
-  cursor: z79.string().min(1).max(1024).optional(),
+var editorialCandidateQuerySchema = z81.object({
+  limit: z81.coerce.number().int().min(1).max(100).default(20),
+  cursor: z81.string().min(1).max(1024).optional(),
   status: editorialCandidateStatusSchema.optional()
 }).strict();
 var editorialKernelQuerySchema = editorialCandidateQuerySchema.extend({ status: contentKernelStatusSchema.optional() }).strict();
-var pageInfo = z79.object({ hasMore: z79.boolean(), nextCursor: z79.string().nullable() });
-var scope = z79.object({
-  projectCode: z79.string(),
-  projectName: z79.string(),
-  canReview: z79.boolean(),
-  canPrepare: z79.boolean()
+var pageInfo = z81.object({ hasMore: z81.boolean(), nextCursor: z81.string().nullable() });
+var scope = z81.object({
+  projectCode: z81.string(),
+  projectName: z81.string(),
+  canReview: z81.boolean(),
+  canPrepare: z81.boolean()
 });
 var editorialCandidatePageSchema = scope.extend({
-  items: z79.array(publicEditorialCandidateSchema),
+  items: z81.array(publicEditorialCandidateSchema),
   pageInfo
 });
 var editorialKernelPageSchema = scope.extend({
-  items: z79.array(publicEditorialKernelSchema),
+  items: z81.array(publicEditorialKernelSchema),
   pageInfo
 });
-var editorialSourceStateSchema = z79.object({
+var editorialSourceStateSchema = z81.object({
   ref: stableRefSchema,
   id: uuidSchema.nullable(),
   sourceType: sourceTypeSchema.nullable(),
-  authority: z79.string().nullable(),
-  observedAt: z79.string().datetime().nullable(),
-  validUntil: z79.string().datetime().nullable(),
-  available: z79.boolean(),
-  reason: z79.enum(["CURRENT", "UNAVAILABLE", "EXPIRED", "CHANGED", "NO_CONTENT"]),
-  contentHash: z79.string().nullable()
-});
-var origin = z79.object({
-  workRequestCode: z79.string(),
-  acceptedAt: z79.string().datetime(),
+  authority: z81.string().nullable(),
+  observedAt: z81.string().datetime().nullable(),
+  validUntil: z81.string().datetime().nullable(),
+  available: z81.boolean(),
+  reason: z81.enum(["CURRENT", "UNAVAILABLE", "EXPIRED", "CHANGED", "NO_CONTENT"]),
+  contentHash: z81.string().nullable()
+});
+var origin = z81.object({
+  workRequestCode: z81.string(),
+  acceptedAt: z81.string().datetime(),
   contract: agentOutputContractReferenceSchema,
   basisSha256: sha,
   contentSha256: sha,
@@ -5958,13 +6065,13 @@ var origin = z79.object({
 var detail = scope.extend({
   reviewSha256: sha,
   recordSha256: sha,
-  basisCurrent: z79.boolean(),
-  sources: z79.array(editorialSourceStateSchema),
+  basisCurrent: z81.boolean(),
+  sources: z81.array(editorialSourceStateSchema),
   origin,
-  canApprove: z79.boolean(),
-  canReject: z79.boolean(),
-  canStartKernel: z79.boolean(),
-  blockedReason: z79.enum([
+  canApprove: z81.boolean(),
+  canReject: z81.boolean(),
+  canStartKernel: z81.boolean(),
+  blockedReason: z81.enum([
     "SOURCE_UNAVAILABLE",
     "TASK_BASIS_CHANGED",
     "KERNEL_EXPIRED",
@@ -5973,198 +6080,184 @@ var detail = scope.extend({
   ]).nullable()
 });
 var editorialCandidateDetailSchema = detail.extend({
-  kind: z79.literal("CANDIDATE"),
+  kind: z81.literal("CANDIDATE"),
   candidate: publicEditorialCandidateSchema
 });
 var editorialKernelDetailSchema = detail.extend({
-  kind: z79.literal("KERNEL"),
+  kind: z81.literal("KERNEL"),
   kernel: publicEditorialKernelSchema
 });
-var editorialReviewReceiptSchema = z79.object({
-  version: z79.literal(1),
+var editorialReviewReceiptSchema = z81.object({
+  version: z81.literal(1),
   requestId: uuidSchema,
   resourceRef: stableRefSchema,
-  actorCode: z79.string(),
-  decidedAt: z79.string().datetime(),
-  decision: z79.enum(["SELECTED", "APPROVED", "REJECTED"]),
-  note: z79.string().nullable(),
-  replayed: z79.boolean(),
-  result: z79.discriminatedUnion("kind", [
-    z79.object({ kind: z79.literal("CANDIDATE"), candidate: publicEditorialCandidateSchema }),
-    z79.object({ kind: z79.literal("KERNEL"), kernel: publicEditorialKernelSchema })
+  actorCode: z81.string(),
+  decidedAt: z81.string().datetime(),
+  decision: z81.enum(["SELECTED", "APPROVED", "REJECTED"]),
+  note: z81.string().nullable(),
+  replayed: z81.boolean(),
+  result: z81.discriminatedUnion("kind", [
+    z81.object({ kind: z81.literal("CANDIDATE"), candidate: publicEditorialCandidateSchema }),
+    z81.object({ kind: z81.literal("KERNEL"), kernel: publicEditorialKernelSchema })
   ])
 });
 
 // packages/contracts/src/foundation/agent-workspace.ts
-import { z as z80 } from "zod";
-var kind = z80.enum(["ORGANIZATION", "PROJECT", "PERSONAL_CONTEXT"]);
-var foundationAgentOverviewInputSchema = z80.object({ workspaceCode: z80.string().regex(/^WSP-[0-9]{6,}$/) }).strict();
-var foundationAgentWorkspaceInputSchema = z80.object({ kind }).strict();
-var foundationAgentProfileSaveSchema = z80.object({ kind, draft: saveFoundationDraftInputSchema }).strict();
-var contextSurvey = saveOrganizationProjectSurveyInputSchema.extend({ expectedEditVersion: z80.number().int().positive().nullable() }).strict();
-var foundationAgentSurveySaveSchema = z80.discriminatedUnion("kind", [
-  z80.object({ kind: z80.literal("ORGANIZATION"), requestId: z80.uuid(), survey: contextSurvey }).strict(),
-  z80.object({ kind: z80.literal("PROJECT"), requestId: z80.uuid(), survey: contextSurvey }).strict(),
-  z80.object({
-    kind: z80.literal("PERSONAL_CONTEXT"),
-    requestId: z80.uuid(),
+import { z as z82 } from "zod";
+var kind = z82.enum(["ORGANIZATION", "PROJECT", "PERSONAL_CONTEXT"]);
+var foundationAgentOverviewInputSchema = z82.object({ workspaceCode: z82.string().regex(/^WSP-[0-9]{6,}$/) }).strict();
+var foundationAgentWorkspaceInputSchema = z82.object({ kind }).strict();
+var foundationAgentProfileSaveSchema = z82.object({ kind, draft: saveFoundationDraftInputSchema }).strict();
+var contextSurvey = saveOrganizationProjectSurveyInputSchema.extend({ expectedEditVersion: z82.number().int().positive().nullable() }).strict();
+var foundationAgentSurveySaveSchema = z82.discriminatedUnion("kind", [
+  z82.object({ kind: z82.literal("ORGANIZATION"), requestId: z82.uuid(), survey: contextSurvey }).strict(),
+  z82.object({ kind: z82.literal("PROJECT"), requestId: z82.uuid(), survey: contextSurvey }).strict(),
+  z82.object({
+    kind: z82.literal("PERSONAL_CONTEXT"),
+    requestId: z82.uuid(),
     survey: personalSurveyResponsesSchema.strict(),
-    expectedEditVersion: z80.number().int().positive().nullable()
+    expectedEditVersion: z82.number().int().positive().nullable()
   }).strict()
 ]);
-var foundationAgentAcceptSchema = z80.object({ kind, adoption: acceptFoundationInputSchema, decision: foundationHumanDecisionSchema }).strict();
-var foundationAgentResearchSchema = z80.object({ kind, research: foundationResearchSaveSchema }).strict();
-var foundationAgentReadingSchema = z80.object({ kind, reading: foundationMaterialReadingSaveSchema }).strict();
-var foundationAgentResearchReplySchema = z80.object({ kind, answer: foundationResearchReplySchema }).strict();
-var foundationAgentChangesSchema = z80.object({ kind, query: foundationChangesQuerySchema }).strict();
-var foundationAgentAckSchema = z80.object({ kind, acknowledgement: foundationChangesAckSchema }).strict();
-var foundationAgentRecordQuerySchema = z80.object({ kind, id: z80.string().uuid(), revision: z80.number().int().positive().optional() }).strict();
-var foundationAgentDecisionReceiptQuerySchema = z80.object({
+var foundationAgentAcceptSchema = z82.object({ kind, adoption: acceptFoundationInputSchema, decision: foundationHumanDecisionSchema }).strict();
+var foundationAgentResearchSchema = z82.object({ kind, research: foundationResearchSaveSchema }).strict();
+var foundationAgentReadingSchema = z82.object({ kind, reading: foundationMaterialReadingSaveSchema }).strict();
+var foundationAgentResearchReplySchema = z82.object({ kind, answer: foundationResearchReplySchema }).strict();
+var foundationAgentChangesSchema = z82.object({ kind, query: foundationChangesQuerySchema }).strict();
+var foundationAgentAckSchema = z82.object({ kind, acknowledgement: foundationChangesAckSchema }).strict();
+var foundationAgentRecordQuerySchema = z82.object({ kind, id: z82.string().uuid(), revision: z82.number().int().positive().optional() }).strict();
+var foundationAgentDecisionReceiptQuerySchema = z82.object({
   kind,
-  requestId: z80.string().min(1).max(160)
+  requestId: z82.string().min(1).max(160)
 }).strict();
-var foundationSaveOperationSchema = z80.enum([
+var foundationSaveOperationSchema = z82.enum([
   "PROFILE",
   "SURVEY",
   "RESEARCH",
   "READING",
   "ANSWER"
 ]);
-var foundationAgentSaveReceiptSchema = z80.object({ kind, operation: foundationSaveOperationSchema, requestId: z80.string().min(1).max(160) }).strict();
-var foundationAgentRevokeSchema = z80.object({
+var foundationAgentSaveReceiptSchema = z82.object({ kind, operation: foundationSaveOperationSchema, requestId: z82.string().min(1).max(160) }).strict();
+var foundationAgentRevokeSchema = z82.object({
   kind,
   revocation: revokeFoundationInputSchema,
   decision: foundationHumanDecisionSchema
 }).strict();
 
 // packages/contracts/src/source-material.ts
-import { z as z81 } from "zod";
+import { z as z83 } from "zod";
 var SOURCE_MATERIAL_MAX_BYTES = 20 * 1024 * 1024;
-var sourceMaterialOriginalSchema = z81.object({
-  sha256: z81.string().regex(/^[a-f0-9]{64}$/),
-  byteSize: z81.number().int().positive().max(SOURCE_MATERIAL_MAX_BYTES),
-  mediaType: z81.string().regex(/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/).max(256),
-  filename: z81.string().min(1).max(240)
+var sourceMaterialOriginalSchema = z83.object({
+  sha256: z83.string().regex(/^[a-f0-9]{64}$/),
+  byteSize: z83.number().int().positive().max(SOURCE_MATERIAL_MAX_BYTES),
+  mediaType: z83.string().regex(/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/).max(256),
+  filename: z83.string().min(1).max(240)
 });
 
 // packages/contracts/src/personal-material.ts
-import { z as z82 } from "zod";
-var personalMaterialRefSchema = z82.string().regex(/^cf:\/\/personal-material\/[0-9a-f-]{36}$/i);
-var personalMaterialSchema = z82.object({
+import { z as z84 } from "zod";
+var personalMaterialRefSchema = z84.string().regex(/^cf:\/\/personal-material\/[0-9a-f-]{36}$/i);
+var personalMaterialSchema = z84.object({
   id: uuidSchema,
   ref: personalMaterialRefSchema,
   ownerUserId: uuidSchema,
   original: sourceMaterialOriginalSchema,
-  createdAt: z82.string().datetime()
+  createdAt: z84.string().datetime()
 });
-var personalMaterialTargetSchema = z82.discriminatedUnion("kind", [
-  z82.object({ kind: z82.literal("ORGANIZATION"), tenantId: uuidSchema }),
-  z82.object({ kind: z82.literal("PROJECT"), tenantId: uuidSchema, projectId: uuidSchema })
+var personalMaterialTargetSchema = z84.discriminatedUnion("kind", [
+  z84.object({ kind: z84.literal("ORGANIZATION"), tenantId: uuidSchema }),
+  z84.object({ kind: z84.literal("PROJECT"), tenantId: uuidSchema, projectId: uuidSchema })
 ]);
-var personalMaterialUseSchema = z82.object({
+var personalMaterialUseSchema = z84.object({
   id: uuidSchema,
   materialId: uuidSchema,
   target: personalMaterialTargetSchema,
-  destinationCode: z82.string().min(1).max(64),
-  destinationName: z82.string().min(1).max(240),
-  active: z82.boolean(),
-  editVersion: z82.number().int().positive(),
-  createdAt: z82.string().datetime(),
-  updatedAt: z82.string().datetime()
-});
-var personalMaterialUseInputSchema = z82.object({
-  active: z82.boolean(),
-  expectedEditVersion: z82.number().int().nonnegative(),
+  destinationCode: z84.string().min(1).max(64),
+  destinationName: z84.string().min(1).max(240),
+  active: z84.boolean(),
+  editVersion: z84.number().int().positive(),
+  createdAt: z84.string().datetime(),
+  updatedAt: z84.string().datetime()
+});
+var personalMaterialUseInputSchema = z84.object({
+  active: z84.boolean(),
+  expectedEditVersion: z84.number().int().nonnegative(),
   requestId: uuidSchema
 }).strict();
-var personalMaterialPageSchema = z82.object({
-  items: z82.array(personalMaterialSchema).max(50),
-  nextCursor: z82.string().nullable()
+var personalMaterialPageSchema = z84.object({
+  items: z84.array(personalMaterialSchema).max(50),
+  nextCursor: z84.string().nullable()
 });
-var personalMaterialListQuerySchema = z82.object({
-  limit: z82.number().int().min(1).max(50).default(20),
-  q: z82.string().trim().max(160).optional(),
-  cursor: z82.string().max(1024).optional()
+var personalMaterialListQuerySchema = z84.object({
+  limit: z84.number().int().min(1).max(50).default(20),
+  q: z84.string().trim().max(160).optional(),
+  cursor: z84.string().max(1024).optional()
 }).strict();
 
 // packages/contracts/src/operating/program-agent-draft.ts
-import { z as z83 } from "zod";
-var programAgentDraftSaveSchema = z83.object({
-  programCode: z83.string().regex(/^CPG-[0-9]{6,}$/u),
-  expectedUpdatedAt: z83.string().datetime(),
+import { z as z85 } from "zod";
+var programAgentDraftSaveSchema = z85.object({
+  programCode: z85.string().regex(/^CPG-[0-9]{6,}$/u),
+  expectedUpdatedAt: z85.string().datetime(),
   content: contentProgramContentSchema,
-  strategies: z83.array(contentProgramChannelStrategyInputSchema).max(64)
+  strategies: z85.array(contentProgramChannelStrategyInputSchema).max(64)
 }).strict();
 
 // packages/contracts/src/publication/package-delivery.ts
-import { z as z84 } from "zod";
-var packageDeliveryInputSchema = z84.object({
-  packageCode: z84.string().regex(/^PKG-[0-9]{6,}$/)
+import { z as z86 } from "zod";
+var packageDeliveryInputSchema = z86.object({
+  packageCode: z86.string().regex(/^PKG-[0-9]{6,}$/)
 }).strict();
-var packageExportRequestSchema = z84.object({
-  retryOf: z84.string().regex(/^JOB-[0-9]{6,}$/).optional()
+var packageExportRequestSchema = z86.object({
+  retryOf: z86.string().regex(/^JOB-[0-9]{6,}$/).optional()
 }).strict().optional();
 var packageExportInputSchema = packageDeliveryInputSchema.extend({
-  retryOf: z84.string().regex(/^JOB-[0-9]{6,}$/).optional()
+  retryOf: z86.string().regex(/^JOB-[0-9]{6,}$/).optional()
 }).strict();
 var packageContentReadInputSchema = packageDeliveryInputSchema.extend({
-  targetKey: z84.string().min(1).max(64).optional()
+  targetKey: z86.string().min(1).max(64).optional()
 }).strict();
-var packageDeliveryViewSchema = z84.object({
-  packageCode: z84.string(),
-  manifestHash: z84.string(),
-  reviewSha256: z84.string().regex(/^[a-f0-9]{64}$/),
+var packageDeliveryViewSchema = z86.object({
+  packageCode: z86.string(),
+  manifestHash: z86.string(),
+  reviewSha256: z86.string().regex(/^[a-f0-9]{64}$/),
   status: contentPackageStatusSchema,
-  capabilities: z84.object({
-    review: z84.boolean(),
-    download: z84.boolean(),
-    recordPublication: z84.boolean()
+  capabilities: z86.object({
+    review: z86.boolean(),
+    download: z86.boolean(),
+    recordPublication: z86.boolean()
   }),
-  export: z84.object({
-    readable: z84.boolean(),
-    unavailable: z84.boolean(),
-    ready: z84.boolean(),
-    work: z84.object({
-      businessCode: z84.string(),
+  export: z86.object({
+    readable: z86.boolean(),
+    unavailable: z86.boolean(),
+    ready: z86.boolean(),
+    work: z86.object({
+      businessCode: z86.string(),
       state: workRequestStateSchema,
-      updatedAt: z84.string().datetime(),
-      errorCode: z84.string().nullable()
+      updatedAt: z86.string().datetime(),
+      errorCode: z86.string().nullable()
     }).nullable()
   })
 });
 
 // packages/contracts/src/feedback-facts.ts
-import { z as z86 } from "zod";
-
-// packages/contracts/src/foundation/command-outcome.ts
-import { z as z85 } from "zod";
-var commandRejectedReceiptSchema = z85.object({
-  state: z85.literal("REJECTED"),
-  result: z85.null(),
-  error: z85.object({
-    code: z85.string().regex(/^[A-Z0-9_]{1,100}$/),
-    outcome: z85.literal("REJECTED"),
-    recovery: z85.string().min(1).max(100)
-  }).strict()
-}).strict();
-
-// packages/contracts/src/feedback-facts.ts
-var feedbackFactIdentitySchema = z86.object({
-  sourceKey: z86.string().trim().min(1).max(128),
-  factKey: z86.string().trim().min(1).max(512).refine((v) => !/[\u0000-\u001f\u007f]/.test(v))
+import { z as z87 } from "zod";
+var feedbackFactIdentitySchema = z87.object({
+  sourceKey: z87.string().trim().min(1).max(128),
+  factKey: z87.string().trim().min(1).max(512).refine((v) => !/[\u0000-\u001f\u007f]/.test(v))
 }).strict();
 var feedbackSourceFactSchema = feedbackFactIdentitySchema.extend({
-  sourceKey: z86.string().regex(/^[a-z][a-z0-9._/-]{0,127}$/).refine((v) => v !== "native"),
-  sourceRevision: z86.number().int().positive().max(2147483647).optional()
+  sourceKey: z87.string().regex(/^[a-z][a-z0-9._/-]{0,127}$/).refine((v) => v !== "native"),
+  sourceRevision: z87.number().int().positive().max(2147483647).optional()
 }).strict();
-var feedbackFactCorrectionSchema = z86.object({
-  observedAt: z86.string().datetime(),
+var feedbackFactCorrectionSchema = z87.object({
+  observedAt: z87.string().datetime(),
   metricWindow: feedbackMetricWindowSchema,
-  periodStart: z86.string().datetime().nullable(),
-  periodEnd: z86.string().datetime().nullable(),
+  periodStart: z87.string().datetime().nullable(),
+  periodEnd: z87.string().datetime().nullable(),
   metrics: feedbackMetricsSchema,
-  note: z86.string().trim().max(8192).nullable(),
-  sourceReference: z86.string().trim().min(1).max(2048).nullable()
+  note: z87.string().trim().max(8192).nullable(),
+  sourceReference: z87.string().trim().min(1).max(2048).nullable()
 }).strict().superRefine((v, ctx) => {
   refineFeedbackMeasurementWindow(v, ctx);
   if (!Object.keys(v.metrics).some((k) => k !== "currency") && !v.note?.trim())
@@ -6172,13 +6265,13 @@ var feedbackFactCorrectionSchema = z86.object({
   if (Object.keys(v.metrics).some((k) => k !== "currency") && !v.sourceReference)
     ctx.addIssue({ code: "custom", message: "Actual metrics need a source reference." });
 });
-var observationCode = z86.string().regex(/^OBS-[0-9]{6,}$/);
-var feedbackFactHttpQuerySchema = z86.object({
+var observationCode = z87.string().regex(/^OBS-[0-9]{6,}$/);
+var feedbackFactHttpQuerySchema = z87.object({
   observationCode: observationCode.optional(),
   sourceKey: feedbackFactIdentitySchema.shape.sourceKey.optional(),
   factKey: feedbackFactIdentitySchema.shape.factKey.optional(),
-  beforeRevision: z86.coerce.number().int().positive().max(2147483647).optional(),
-  limit: z86.coerce.number().int().min(1).max(30).default(10)
+  beforeRevision: z87.coerce.number().int().positive().max(2147483647).optional(),
+  limit: z87.coerce.number().int().min(1).max(30).default(10)
 }).strict().superRefine((v, ctx) => {
   if (v.observationCode ? v.sourceKey !== void 0 || v.factKey !== void 0 : !v.sourceKey || !v.factKey)
     ctx.addIssue({
@@ -6186,109 +6279,109 @@ var feedbackFactHttpQuerySchema = z86.object({
       message: "Use an observation code or an exact source/fact key pair."
     });
 });
-var feedbackFactReadSchema = z86.union([
-  z86.object({
+var feedbackFactReadSchema = z87.union([
+  z87.object({
     observationCode,
-    beforeRevision: z86.coerce.number().int().positive().max(2147483647).optional(),
-    limit: z86.coerce.number().int().min(1).max(30).default(10)
+    beforeRevision: z87.coerce.number().int().positive().max(2147483647).optional(),
+    limit: z87.coerce.number().int().min(1).max(30).default(10)
   }).strict(),
-  z86.object({
+  z87.object({
     identity: feedbackFactIdentitySchema,
-    beforeRevision: z86.coerce.number().int().positive().max(2147483647).optional(),
-    limit: z86.coerce.number().int().min(1).max(30).default(10)
+    beforeRevision: z87.coerce.number().int().positive().max(2147483647).optional(),
+    limit: z87.coerce.number().int().min(1).max(30).default(10)
   }).strict()
 ]);
 var change = {
-  requestId: z86.uuid(),
+  requestId: z87.uuid(),
   observationCode,
-  expectedRevision: z86.number().int().positive().max(2147483647),
-  expectedAccountUpdatedAt: z86.string().datetime(),
-  reason: z86.string().trim().min(1).max(2048),
-  sourceRevision: z86.number().int().positive().max(2147483647).optional()
+  expectedRevision: z87.number().int().positive().max(2147483647),
+  expectedAccountUpdatedAt: z87.string().datetime(),
+  reason: z87.string().trim().min(1).max(2048),
+  sourceRevision: z87.number().int().positive().max(2147483647).optional()
 };
-var feedbackFactChangeSchema = z86.discriminatedUnion("operation", [
-  z86.object({
+var feedbackFactChangeSchema = z87.discriminatedUnion("operation", [
+  z87.object({
     ...change,
-    operation: z86.literal("CORRECT"),
+    operation: z87.literal("CORRECT"),
     correction: feedbackFactCorrectionSchema
   }).strict(),
-  z86.object({ ...change, operation: z86.literal("WITHDRAW") }).strict()
+  z87.object({ ...change, operation: z87.literal("WITHDRAW") }).strict()
 ]);
-var feedbackFactSchema = z86.object({
+var feedbackFactSchema = z87.object({
   identity: feedbackFactIdentitySchema,
-  revision: z86.number().int().positive(),
-  sourceRevision: z86.number().int().positive().nullable(),
-  state: z86.enum(["CURRENT", "WITHDRAWN"]),
+  revision: z87.number().int().positive(),
+  sourceRevision: z87.number().int().positive().nullable(),
+  state: z87.enum(["CURRENT", "WITHDRAWN"]),
   current: feedbackObservationSchema.nullable(),
-  updatedAt: z86.string().datetime()
+  updatedAt: z87.string().datetime()
 });
-var feedbackFactChangeReceiptSchema = z86.object({
+var feedbackFactChangeReceiptSchema = z87.object({
   observationCode,
-  revision: z86.number().int().positive(),
-  state: z86.enum(["CURRENT", "WITHDRAWN"]),
-  destinationCode: z86.string(),
-  replayed: z86.boolean()
-});
-var feedbackFactOriginalReceiptSchema = z86.discriminatedUnion("state", [
-  z86.object({ state: z86.literal("FOUND"), result: feedbackFactChangeReceiptSchema }),
-  z86.object({ state: z86.literal("NOT_FOUND"), result: z86.null() }),
+  revision: z87.number().int().positive(),
+  state: z87.enum(["CURRENT", "WITHDRAWN"]),
+  destinationCode: z87.string(),
+  replayed: z87.boolean()
+});
+var feedbackFactOriginalReceiptSchema = z87.discriminatedUnion("state", [
+  z87.object({ state: z87.literal("FOUND"), result: feedbackFactChangeReceiptSchema }),
+  z87.object({ state: z87.literal("NOT_FOUND"), result: z87.null() }),
   commandRejectedReceiptSchema
 ]);
 var feedbackFactDocumentSchema = feedbackFactSchema.extend({
   lastObservation: feedbackObservationSchema.nullable().default(null),
-  canChange: z86.boolean(),
-  destinationCode: z86.string(),
-  accountUpdatedAt: z86.string().datetime(),
-  history: z86.array(
-    z86.object({
-      revision: z86.number().int().positive(),
-      sourceRevision: z86.number().int().positive().nullable(),
-      operation: z86.enum(["OBSERVE", "CORRECT", "WITHDRAW"]),
+  canChange: z87.boolean(),
+  destinationCode: z87.string(),
+  accountUpdatedAt: z87.string().datetime(),
+  history: z87.array(
+    z87.object({
+      revision: z87.number().int().positive(),
+      sourceRevision: z87.number().int().positive().nullable(),
+      operation: z87.enum(["OBSERVE", "CORRECT", "WITHDRAW"]),
       observation: feedbackObservationSchema.nullable(),
-      reason: z86.string().nullable(),
-      createdAt: z86.string().datetime()
+      reason: z87.string().nullable(),
+      createdAt: z87.string().datetime()
     })
   ),
-  hasMore: z86.boolean(),
-  nextBeforeRevision: z86.number().int().positive().nullable().default(null)
+  hasMore: z87.boolean(),
+  nextBeforeRevision: z87.number().int().positive().nullable().default(null)
 });
-var feedbackFactAgentReadSchema = z86.union([
+var feedbackFactAgentReadSchema = z87.union([
   feedbackFactReadSchema.options[0].extend({
-    destinationCode: z86.string().regex(/^DST-[0-9]{6,}$/)
+    destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/)
   }),
   feedbackFactReadSchema.options[1].extend({
-    destinationCode: z86.string().regex(/^DST-[0-9]{6,}$/)
+    destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/)
   })
 ]);
-var feedbackFactAgentChangeSchema = z86.discriminatedUnion("operation", [
+var feedbackFactAgentChangeSchema = z87.discriminatedUnion("operation", [
   feedbackFactChangeSchema.options[0].extend({
-    destinationCode: z86.string().regex(/^DST-[0-9]{6,}$/)
+    destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/)
   }),
   feedbackFactChangeSchema.options[1].extend({
-    destinationCode: z86.string().regex(/^DST-[0-9]{6,}$/)
+    destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/)
   })
 ]);
-var feedbackFactAgentReceiptSchema = z86.object({ requestId: z86.uuid(), destinationCode: z86.string().regex(/^DST-[0-9]{6,}$/) }).strict();
+var feedbackFactAgentReceiptSchema = z87.object({ requestId: z87.uuid(), destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/) }).strict();
 
 // packages/contracts/src/channel-feedback.ts
-import { z as z87 } from "zod";
-var channelFeedbackCommandSchema = z87.object({
+import { z as z88 } from "zod";
+var channelFeedbackCommandSchema = z88.object({
   fact: feedbackSourceFactSchema.optional(),
-  requestId: z87.uuid(),
-  expectedAccountUpdatedAt: z87.string().datetime(),
-  sourceName: z87.string().trim().min(1).max(128),
-  sourceReference: z87.string().trim().min(1).max(2048).nullable(),
-  observedAt: z87.string().datetime(),
+  requestId: z88.uuid(),
+  expectedAccountUpdatedAt: z88.string().datetime(),
+  sourceName: z88.string().trim().min(1).max(128),
+  sourceReference: z88.string().trim().min(1).max(2048).nullable(),
+  observedAt: z88.string().datetime(),
   metricWindow: feedbackMetricWindowSchema,
-  periodStart: z87.string().datetime().nullable(),
-  periodEnd: z87.string().datetime().nullable(),
+  periodStart: z88.string().datetime().nullable(),
+  periodEnd: z88.string().datetime().nullable(),
   metrics: feedbackMetricsSchema,
-  note: z87.string().trim().max(8192).nullable(),
-  publicationCode: z87.string().regex(/^PUB-[0-9]{6,}$/).nullable(),
-  goal: z87.object({
-    programCode: z87.string().regex(/^CPG-[0-9]{6,}$/),
-    revision: z87.number().int().positive(),
-    goalId: z87.string().min(1).max(64)
+  note: z88.string().trim().max(8192).nullable(),
+  publicationCode: z88.string().regex(/^PUB-[0-9]{6,}$/).nullable(),
+  goal: z88.object({
+    programCode: z88.string().regex(/^CPG-[0-9]{6,}$/),
+    revision: z88.number().int().positive(),
+    goalId: z88.string().min(1).max(64)
   }).strict().nullable()
 }).strict().superRefine((v, ctx) => {
   if (!Object.keys(v.metrics).some((k) => k !== "currency") && !v.note?.trim())
@@ -6302,177 +6395,177 @@ var channelFeedbackCommandSchema = z87.object({
   if ((v.metrics.attributedRevenueAmount !== void 0 || v.metrics.adSpendAmount !== void 0) && !v.metrics.currency)
     ctx.addIssue({ code: "custom", message: "Currency required." });
 });
-var channelFeedbackQuerySchema = z87.object({
-  view: z87.enum(["CURRENT", "HISTORY"]).default("CURRENT"),
-  limit: z87.coerce.number().int().min(1).max(50).default(10),
-  afterBusinessCode: z87.string().regex(/^OBS-[0-9]{6,}$/).optional()
+var channelFeedbackQuerySchema = z88.object({
+  view: z88.enum(["CURRENT", "HISTORY"]).default("CURRENT"),
+  limit: z88.coerce.number().int().min(1).max(50).default(10),
+  afterBusinessCode: z88.string().regex(/^OBS-[0-9]{6,}$/).optional()
 }).strict();
-var channelFeedbackPageSchema = z87.object({
-  canRecord: z87.boolean(),
-  items: z87.array(feedbackObservationSchema),
-  hasMore: z87.boolean(),
-  nextAfterBusinessCode: z87.string().nullable()
+var channelFeedbackPageSchema = z88.object({
+  canRecord: z88.boolean(),
+  items: z88.array(feedbackObservationSchema),
+  hasMore: z88.boolean(),
+  nextAfterBusinessCode: z88.string().nullable()
 }).strict();
-var channelFeedbackReceiptSchema = z87.object({ observationCode: z87.string(), observedAt: z87.string().datetime(), replayed: z87.boolean() }).strict();
+var channelFeedbackReceiptSchema = z88.object({ observationCode: z88.string(), observedAt: z88.string().datetime(), replayed: z88.boolean() }).strict();
 var channelFeedbackReadSchema = channelFeedbackQuerySchema.extend({
-  destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/)
+  destinationCode: z88.string().regex(/^DST-[0-9]{6,}$/)
 });
 var channelFeedbackWriteSchema = channelFeedbackCommandSchema.safeExtend({
-  destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/)
+  destinationCode: z88.string().regex(/^DST-[0-9]{6,}$/)
 });
-var channelFeedbackReceiptQuerySchema = z87.object({ requestId: z87.uuid() }).strict();
-var channelFeedbackOriginalReceiptSchema = z87.discriminatedUnion("state", [
-  z87.object({ state: z87.literal("FOUND"), result: channelFeedbackReceiptSchema }).strict(),
-  z87.object({ state: z87.literal("NOT_FOUND"), result: z87.null() }).strict(),
+var channelFeedbackReceiptQuerySchema = z88.object({ requestId: z88.uuid() }).strict();
+var channelFeedbackOriginalReceiptSchema = z88.discriminatedUnion("state", [
+  z88.object({ state: z88.literal("FOUND"), result: channelFeedbackReceiptSchema }).strict(),
+  z88.object({ state: z88.literal("NOT_FOUND"), result: z88.null() }).strict(),
   commandRejectedReceiptSchema
 ]);
 var channelFeedbackAgentReceiptSchema = channelFeedbackReceiptQuerySchema.extend({
-  destinationCode: z87.string().regex(/^DST-[0-9]{6,}$/)
+  destinationCode: z88.string().regex(/^DST-[0-9]{6,}$/)
 });
 
 // packages/contracts/src/business-objects.ts
-import { z as z88 } from "zod";
-var workspaceCode = z88.string().regex(/^WSP-[0-9]{6,}$/);
-var page = z88.object({
-  limit: z88.number().int().min(1).max(20).default(8),
-  cursor: z88.string().max(2e3).optional()
-}).strict();
-var businessObjectsQuerySchema = z88.discriminatedUnion("kind", [
-  page.extend({ kind: z88.literal("ORGANIZATIONS") }).strict(),
-  page.extend({ kind: z88.literal("WORKSPACES") }).strict(),
+import { z as z89 } from "zod";
+var workspaceCode = z89.string().regex(/^WSP-[0-9]{6,}$/);
+var page = z89.object({
+  limit: z89.number().int().min(1).max(20).default(8),
+  cursor: z89.string().max(2e3).optional()
+}).strict();
+var businessObjectsQuerySchema = z89.discriminatedUnion("kind", [
+  page.extend({ kind: z89.literal("ORGANIZATIONS") }).strict(),
+  page.extend({ kind: z89.literal("WORKSPACES") }).strict(),
   page.extend({
-    kind: z88.literal("PROJECTS"),
+    kind: z89.literal("PROJECTS"),
     workspaceCode,
-    search: z88.string().trim().min(1).max(160).optional(),
+    search: z89.string().trim().min(1).max(160).optional(),
     status: projectStatusSchema.optional()
   }).strict()
 ]);
-var projectCreationCommandSchema = z88.object({
+var projectCreationCommandSchema = z89.object({
   key: projectKeySchema,
-  name: z88.string().trim().min(1).max(160),
-  requestId: z88.string().min(1).max(128)
+  name: z89.string().trim().min(1).max(160),
+  requestId: z89.string().min(1).max(128)
 }).strict();
 var agentProjectCreationSchema = projectCreationCommandSchema.extend({ workspaceCode }).strict();
-var projectCreationReceiptQuerySchema = z88.object({ workspaceCode, requestId: z88.string().min(1).max(128) }).strict();
-var result = z88.object({
-  project: z88.object({
-    businessCode: z88.string().regex(/^PRJ-[0-9]{6,}$/),
+var projectCreationReceiptQuerySchema = z89.object({ workspaceCode, requestId: z89.string().min(1).max(128) }).strict();
+var result = z89.object({
+  project: z89.object({
+    businessCode: z89.string().regex(/^PRJ-[0-9]{6,}$/),
     key: projectKeySchema,
-    name: z88.string(),
+    name: z89.string(),
     status: projectStatusSchema,
     workspaceCode,
-    tenantCode: z88.string().regex(/^TEN-[0-9]{6,}$/)
+    tenantCode: z89.string().regex(/^TEN-[0-9]{6,}$/)
   }).strict(),
-  connection: z88.object({ resource: z88.string().url(), authorizationRequired: z88.literal(true) }).strict()
+  connection: z89.object({ resource: z89.string().url(), authorizationRequired: z89.literal(true) }).strict()
 }).strict();
-var projectCreationResultSchema = result.extend({ replayed: z88.boolean() }).strict();
-var projectCreationReceiptSchema = z88.discriminatedUnion("state", [
-  z88.object({ state: z88.literal("FOUND"), result }).strict(),
-  z88.object({ state: z88.literal("NOT_FOUND"), result: z88.null() }).strict()
+var projectCreationResultSchema = result.extend({ replayed: z89.boolean() }).strict();
+var projectCreationReceiptSchema = z89.discriminatedUnion("state", [
+  z89.object({ state: z89.literal("FOUND"), result }).strict(),
+  z89.object({ state: z89.literal("NOT_FOUND"), result: z89.null() }).strict()
 ]);
 
 // packages/contracts/src/foundation/survey-operations.ts
-import { z as z89 } from "zod";
-var kind2 = z89.enum(["ORGANIZATION", "PROJECT", "PERSONAL_CONTEXT"]);
-var foundationSurveyOperationSchema = z89.enum(["SUBMIT", "UPDATE_INSTRUMENT"]);
-var foundationSurveyCommandSchema = z89.object({
+import { z as z90 } from "zod";
+var kind2 = z90.enum(["ORGANIZATION", "PROJECT", "PERSONAL_CONTEXT"]);
+var foundationSurveyOperationSchema = z90.enum(["SUBMIT", "UPDATE_INSTRUMENT"]);
+var foundationSurveyCommandSchema = z90.object({
   kind: kind2,
-  surveyCode: z89.string().regex(/^SRV-[0-9]{6,}$/),
-  expectedEditVersion: z89.number().int().positive(),
-  requestId: z89.string().min(1).max(128)
+  surveyCode: z90.string().regex(/^SRV-[0-9]{6,}$/),
+  expectedEditVersion: z90.number().int().positive(),
+  requestId: z90.string().min(1).max(128)
 }).strict();
-var foundationSurveyReceiptQuerySchema = z89.object({
+var foundationSurveyReceiptQuerySchema = z90.object({
   kind: kind2,
   operation: foundationSurveyOperationSchema,
-  requestId: z89.string().min(1).max(128)
+  requestId: z90.string().min(1).max(128)
 }).strict();
 
 // packages/contracts/src/source-registration.ts
-import { z as z90 } from "zod";
-var requestId2 = z90.string().min(1).max(128);
+import { z as z91 } from "zod";
+var requestId2 = z91.string().min(1).max(128);
 var sourceRegistrationCommandSchema = sourceObservationInputSchema.safeExtend({ requestId: requestId2 }).strict();
-var sourceLinksCommandSchema = z90.object({
+var sourceLinksCommandSchema = z91.object({
   requestId: requestId2,
-  urls: z90.array(z90.string().max(2048)).min(1).max(20)
+  urls: z91.array(z91.string().max(2048)).min(1).max(20)
 }).strict();
-var sourceRegistrationReceiptQuerySchema = z90.object({
-  operation: z90.enum(["REGISTER", "LINKS"]),
+var sourceRegistrationReceiptQuerySchema = z91.object({
+  operation: z91.enum(["REGISTER", "LINKS"]),
   requestId: requestId2
 }).strict();
-var sourceRegistrationTargetSchema = z90.discriminatedUnion("kind", [
-  z90.object({ kind: z90.literal("ORGANIZATION"), tenantCode: z90.string().regex(/^TEN-[0-9]{6,}$/) }).strict(),
-  z90.object({ kind: z90.literal("PROJECT"), projectCode: z90.string().regex(/^PRJ-[0-9]{6,}$/) }).strict()
+var sourceRegistrationTargetSchema = z91.discriminatedUnion("kind", [
+  z91.object({ kind: z91.literal("ORGANIZATION"), tenantCode: z91.string().regex(/^TEN-[0-9]{6,}$/) }).strict(),
+  z91.object({ kind: z91.literal("PROJECT"), projectCode: z91.string().regex(/^PRJ-[0-9]{6,}$/) }).strict()
 ]);
-var sourceLinksResultSchema = z90.object({
-  entries: z90.array(
-    z90.object({
-      index: z90.number().int(),
-      input: z90.string(),
-      state: z90.enum(["ADDED", "DUPLICATE", "INVALID"]),
+var sourceLinksResultSchema = z91.object({
+  entries: z91.array(
+    z91.object({
+      index: z91.number().int(),
+      input: z91.string(),
+      state: z91.enum(["ADDED", "DUPLICATE", "INVALID"]),
       source: sourceRefSchema.nullable(),
-      message: z90.string().nullable()
+      message: z91.string().nullable()
     }).strict()
   ),
-  registeredOnly: z90.literal(true)
+  registeredOnly: z91.literal(true)
 }).strict();
-var sourceRegistrationReceiptSchema = z90.discriminatedUnion("state", [
-  z90.object({
-    state: z90.literal("FOUND"),
-    result: z90.union([sourceRefSchema, sourceLinksResultSchema])
+var sourceRegistrationReceiptSchema = z91.discriminatedUnion("state", [
+  z91.object({
+    state: z91.literal("FOUND"),
+    result: z91.union([sourceRefSchema, sourceLinksResultSchema])
   }).strict(),
-  z90.object({ state: z90.literal("NOT_FOUND"), result: z90.null() }).strict(),
+  z91.object({ state: z91.literal("NOT_FOUND"), result: z91.null() }).strict(),
   commandRejectedReceiptSchema
 ]);
-var sourceLinksCommandResultSchema = z90.object({ result: sourceLinksResultSchema, replayed: z90.boolean() }).strict();
+var sourceLinksCommandResultSchema = z91.object({ result: sourceLinksResultSchema, replayed: z91.boolean() }).strict();
 
 // packages/contracts/src/material-upload.ts
-import { z as z91 } from "zod";
-var materialUploadTargetSchema = z91.discriminatedUnion("kind", [
-  z91.object({ kind: z91.literal("PERSONAL") }).strict(),
-  z91.object({ kind: z91.literal("ORGANIZATION"), tenantCode: businessCodeSchema }).strict(),
-  z91.object({ kind: z91.literal("PROJECT"), projectCode: businessCodeSchema }).strict()
+import { z as z92 } from "zod";
+var materialUploadTargetSchema = z92.discriminatedUnion("kind", [
+  z92.object({ kind: z92.literal("PERSONAL") }).strict(),
+  z92.object({ kind: z92.literal("ORGANIZATION"), tenantCode: businessCodeSchema }).strict(),
+  z92.object({ kind: z92.literal("PROJECT"), projectCode: businessCodeSchema }).strict()
 ]);
-var materialUploadQuerySchema = z91.object({ requestId: uuidSchema }).strict();
+var materialUploadQuerySchema = z92.object({ requestId: uuidSchema }).strict();
 var materialUploadCommandSchema = materialUploadQuerySchema.extend({
-  filename: z91.string().trim().min(1).max(240).refine(
+  filename: z92.string().trim().min(1).max(240).refine(
     (value) => !/[\\/\u0000-\u001f\u007f]/.test(value),
     "Use an original basename without control characters."
   ),
-  byteSize: z91.number().int().min(1).max(SOURCE_MATERIAL_MAX_BYTES),
-  sha256: z91.string().regex(/^[a-f0-9]{64}$/)
+  byteSize: z92.number().int().min(1).max(SOURCE_MATERIAL_MAX_BYTES),
+  sha256: z92.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var materialUploadResultSchema = z91.discriminatedUnion("kind", [
-  z91.object({ kind: z91.literal("PERSONAL"), material: personalMaterialSchema }),
-  z91.object({ kind: z91.enum(["ORGANIZATION", "PROJECT"]), source: sourceRefSchema })
+var materialUploadResultSchema = z92.discriminatedUnion("kind", [
+  z92.object({ kind: z92.literal("PERSONAL"), material: personalMaterialSchema }),
+  z92.object({ kind: z92.enum(["ORGANIZATION", "PROJECT"]), source: sourceRefSchema })
 ]);
-var materialUploadReceiptSchema = z91.object({
-  state: z91.enum(["FOUND", "NOT_FOUND"]),
+var materialUploadReceiptSchema = z92.object({
+  state: z92.enum(["FOUND", "NOT_FOUND"]),
   result: materialUploadResultSchema.nullable()
 });
 var materialUploadPreparedSchema = materialUploadCommandSchema.extend({
-  maxBytes: z91.number().int().positive(),
-  uploadPath: z91.string().min(1).max(1024),
-  method: z91.literal("POST"),
-  contentType: z91.literal("multipart/form-data"),
-  fileField: z91.literal("file"),
-  authentication: z91.literal("CF_OAUTH"),
-  preparedOnly: z91.literal(true)
-});
-var materialUploadCommandResultSchema = z91.object({
+  maxBytes: z92.number().int().positive(),
+  uploadPath: z92.string().min(1).max(1024),
+  method: z92.literal("POST"),
+  contentType: z92.literal("multipart/form-data"),
+  fileField: z92.literal("file"),
+  authentication: z92.literal("CF_OAUTH"),
+  preparedOnly: z92.literal(true)
+});
+var materialUploadCommandResultSchema = z92.object({
   result: materialUploadResultSchema,
-  replayed: z91.boolean()
+  replayed: z92.boolean()
 });
 
 // packages/contracts/src/material-reuse.ts
-import { z as z92 } from "zod";
-var personalMaterialDetailQuerySchema = z92.object({ materialId: uuidSchema }).strict();
+import { z as z93 } from "zod";
+var personalMaterialDetailQuerySchema = z93.object({ materialId: uuidSchema }).strict();
 var personalMaterialUsesQuerySchema = personalMaterialDetailQuerySchema.extend({
-  limit: z92.number().int().min(1).max(20).default(8),
-  cursor: z92.string().max(2048).optional()
+  limit: z93.number().int().min(1).max(20).default(8),
+  cursor: z93.string().max(2048).optional()
 }).strict();
 var command3 = personalMaterialDetailQuerySchema.extend({
   requestId: uuidSchema,
-  expectedEditVersion: z92.number().int().nonnegative()
+  expectedEditVersion: z93.number().int().nonnegative()
 });
 var personalMaterialGrantCommandSchema = command3.extend({
   target: sourceRegistrationTargetSchema,
@@ -6484,197 +6577,197 @@ var personalMaterialStopCommandSchema = command3.extend({
 }).strict();
 var personalMaterialUseReceiptQuerySchema = personalMaterialDetailQuerySchema.extend({
   requestId: uuidSchema,
-  operation: z92.enum(["GRANT", "STOP"])
+  operation: z93.enum(["GRANT", "STOP"])
 }).strict();
-var personalMaterialUseResultSchema = z92.object({
+var personalMaterialUseResultSchema = z93.object({
   use: personalMaterialUseSchema,
   origin: businessWriteOriginSchema
 }).strict();
-var personalMaterialUseReceiptSchema = z92.discriminatedUnion("state", [
-  z92.object({ state: z92.literal("FOUND"), result: personalMaterialUseResultSchema }).strict(),
-  z92.object({ state: z92.literal("NOT_FOUND"), result: z92.null() }).strict(),
+var personalMaterialUseReceiptSchema = z93.discriminatedUnion("state", [
+  z93.object({ state: z93.literal("FOUND"), result: personalMaterialUseResultSchema }).strict(),
+  z93.object({ state: z93.literal("NOT_FOUND"), result: z93.null() }).strict(),
   commandRejectedReceiptSchema
 ]);
 
 // packages/contracts/src/source-binding.ts
-import { z as z93 } from "zod";
-var sourceCandidatesQuerySchema = z93.object({
-  q: z93.string().trim().max(160).optional(),
+import { z as z94 } from "zod";
+var sourceCandidatesQuerySchema = z94.object({
+  q: z94.string().trim().max(160).optional(),
   sourceType: sourceTypeSchema.optional(),
-  limit: z93.number().int().min(1).max(20).default(8),
-  cursor: z93.string().max(2048).optional()
+  limit: z94.number().int().min(1).max(20).default(8),
+  cursor: z94.string().max(2048).optional()
 }).strict();
-var sourceBindingCommandSchema = z93.object({
+var sourceBindingCommandSchema = z94.object({
   sourceId: uuidSchema,
-  expectedBound: z93.boolean(),
+  expectedBound: z94.boolean(),
   requestId: uuidSchema
 }).strict();
-var sourceBindingResultSchema = z93.object({ sourceRef: z93.string(), binding: projectSourceBindingSchema }).strict();
-var sourceBindingReceiptQuerySchema = z93.object({ requestId: uuidSchema }).strict();
-var sourceBindingReceiptSchema = z93.discriminatedUnion("state", [
-  z93.object({ state: z93.literal("FOUND"), result: sourceBindingResultSchema }).strict(),
-  z93.object({ state: z93.literal("NOT_FOUND"), result: z93.null() }).strict(),
+var sourceBindingResultSchema = z94.object({ sourceRef: z94.string(), binding: projectSourceBindingSchema }).strict();
+var sourceBindingReceiptQuerySchema = z94.object({ requestId: uuidSchema }).strict();
+var sourceBindingReceiptSchema = z94.discriminatedUnion("state", [
+  z94.object({ state: z94.literal("FOUND"), result: sourceBindingResultSchema }).strict(),
+  z94.object({ state: z94.literal("NOT_FOUND"), result: z94.null() }).strict(),
   commandRejectedReceiptSchema
 ]);
 
 // packages/contracts/src/operating/strategy-commands.ts
-import { z as z94 } from "zod";
-var programCommandReceiptSchema = z94.discriminatedUnion("state", [
-  z94.object({ state: z94.literal("FOUND"), result: z94.unknown() }),
-  z94.object({ state: z94.literal("NOT_FOUND"), result: z94.null() }),
+import { z as z95 } from "zod";
+var programCommandReceiptSchema = z95.discriminatedUnion("state", [
+  z95.object({ state: z95.literal("FOUND"), result: z95.unknown() }),
+  z95.object({ state: z95.literal("NOT_FOUND"), result: z95.null() }),
   commandRejectedReceiptSchema
 ]);
-var requestId3 = z94.string().uuid();
-var fingerprint = z94.string().regex(/^[a-f0-9]{64}$/);
-var programDraftOpenCommandSchema = z94.object({
+var requestId3 = z95.string().uuid();
+var fingerprint = z95.string().regex(/^[a-f0-9]{64}$/);
+var programDraftOpenCommandSchema = z95.object({
   requestId: requestId3,
   expectedPreparationFingerprint: fingerprint,
-  expectedDraft: z94.object({ programCode: businessCodeSchema, updatedAt: z94.string().datetime() }).strict().nullable()
+  expectedDraft: z95.object({ programCode: businessCodeSchema, updatedAt: z95.string().datetime() }).strict().nullable()
 }).strict();
 var programDraftSaveCommandSchema = programAgentDraftSaveSchema.extend({ requestId: requestId3 }).strict();
-var programActivationCommandSchema = z94.object({
+var programActivationCommandSchema = z95.object({
   requestId: requestId3,
   programCode: businessCodeSchema,
-  expectedUpdatedAt: z94.string().datetime(),
+  expectedUpdatedAt: z95.string().datetime(),
   foundationBasis: foundationProgramBasisSchema,
   decision: humanDecisionDeclarationSchema.optional()
 }).strict();
-var programCommandReceiptQuerySchema = z94.object({ operation: z94.enum(["OPEN", "SAVE", "REBASE", "ACTIVATE", "APPLY"]), requestId: requestId3 }).strict();
-var goalObservationCommandSchema = z94.object({
+var programCommandReceiptQuerySchema = z95.object({ operation: z95.enum(["OPEN", "SAVE", "REBASE", "ACTIVATE", "APPLY"]), requestId: requestId3 }).strict();
+var goalObservationCommandSchema = z95.object({
   requestId: requestId3,
   programCode: businessCodeSchema,
-  expectedProgramUpdatedAt: z94.string().datetime(),
-  goalId: z94.string().min(1).max(64),
-  startsAt: z94.string().datetime(),
-  endsAt: z94.string().datetime(),
-  value: z94.number().finite().nonnegative(),
-  sourceName: z94.string().trim().min(1).max(128),
-  sourceReference: z94.string().trim().min(1).max(2048),
-  sourceMode: z94.enum(["HUMAN", "API_ADAPTER"]),
-  observedAt: z94.string().datetime(),
-  note: z94.string().max(8192).nullable()
-}).strict();
-var goalObservationReceiptQuerySchema = z94.object({ requestId: requestId3 }).strict();
-var programBasisCommandSchema = z94.object({
+  expectedProgramUpdatedAt: z95.string().datetime(),
+  goalId: z95.string().min(1).max(64),
+  startsAt: z95.string().datetime(),
+  endsAt: z95.string().datetime(),
+  value: z95.number().finite().nonnegative(),
+  sourceName: z95.string().trim().min(1).max(128),
+  sourceReference: z95.string().trim().min(1).max(2048),
+  sourceMode: z95.enum(["HUMAN", "API_ADAPTER"]),
+  observedAt: z95.string().datetime(),
+  note: z95.string().max(8192).nullable()
+}).strict();
+var goalObservationReceiptQuerySchema = z95.object({ requestId: requestId3 }).strict();
+var programBasisCommandSchema = z95.object({
   requestId: requestId3,
   programCode: businessCodeSchema,
-  expectedUpdatedAt: z94.string().datetime(),
+  expectedUpdatedAt: z95.string().datetime(),
   foundationBasis: foundationProgramBasisSchema
 }).strict();
-var programSuggestionReadSchema = z94.object({ candidateCode: businessCodeSchema.optional(), workCode: businessCodeSchema.optional() }).strict().refine((v) => Boolean(v.candidateCode) !== Boolean(v.workCode));
-var programSuggestionApplySchema = z94.object({
+var programSuggestionReadSchema = z95.object({ candidateCode: businessCodeSchema.optional(), workCode: businessCodeSchema.optional() }).strict().refine((v) => Boolean(v.candidateCode) !== Boolean(v.workCode));
+var programSuggestionApplySchema = z95.object({
   candidateCode: businessCodeSchema,
-  expectedUpdatedAt: z94.string().datetime().nullable(),
+  expectedUpdatedAt: z95.string().datetime().nullable(),
   requestId: requestId3
 }).strict();
-var programPreparationViewSchema = z94.object({
-  basis: z94.object({
-    version: z94.literal(1),
+var programPreparationViewSchema = z95.object({
+  basis: z95.object({
+    version: z95.literal(1),
     fingerprint,
-    sourceRefs: z94.array(z94.string()).max(24),
+    sourceRefs: z95.array(z95.string()).max(24),
     goalFingerprint: fingerprint
   }).strict(),
   adoptionBasis: foundationProgramBasisSchema.nullable(),
-  goals: z94.array(z94.object({ id: z94.string(), outcome: z94.string() })).max(12),
-  alignment: z94.object({ basisFingerprint: fingerprint, goalFingerprint: fingerprint }),
-  currentDraft: z94.object({ programCode: businessCodeSchema, updatedAt: z94.string().datetime() }).nullable(),
-  referenceOnly: z94.boolean(),
-  inputRead: z94.object({
-    capability: z94.string(),
-    input: z94.object({ kind: z94.literal("PROJECT") })
+  goals: z95.array(z95.object({ id: z95.string(), outcome: z95.string() })).max(12),
+  alignment: z95.object({ basisFingerprint: fingerprint, goalFingerprint: fingerprint }),
+  currentDraft: z95.object({ programCode: businessCodeSchema, updatedAt: z95.string().datetime() }).nullable(),
+  referenceOnly: z95.boolean(),
+  inputRead: z95.object({
+    capability: z95.string(),
+    input: z95.object({ kind: z95.literal("PROJECT") })
   }),
-  alignmentSave: z94.object({
-    capability: z94.string(),
-    kind: z94.literal("PROJECT"),
+  alignmentSave: z95.object({
+    capability: z95.string(),
+    kind: z95.literal("PROJECT"),
     expectedBasisFingerprint: fingerprint,
     expectedGoalFingerprint: fingerprint
   }),
-  authority: z94.object({ preparationIsAdoption: z94.literal(false) })
+  authority: z95.object({ preparationIsAdoption: z95.literal(false) })
 }).strict();
-var programCommandResultSchema = z94.object({
+var programCommandResultSchema = z95.object({
   programCode: businessCodeSchema,
-  updatedAt: z94.string().datetime(),
-  status: z94.enum(["DRAFT", "ACTIVE", "SUPERSEDED"]),
-  activated: z94.boolean(),
-  referenceOnly: z94.boolean(),
+  updatedAt: z95.string().datetime(),
+  status: z95.enum(["DRAFT", "ACTIVE", "SUPERSEDED"]),
+  activated: z95.boolean(),
+  referenceOnly: z95.boolean(),
   origin: businessWriteOriginSchema
 }).strict();
-var programCommandEnvelopeSchema = z94.object({ result: programCommandResultSchema, replayed: z94.boolean() }).strict();
-var programGoalOptionsQuerySchema = z94.object({ programCode: businessCodeSchema, goalId: z94.string().min(1).max(64).optional() }).strict();
+var programCommandEnvelopeSchema = z95.object({ result: programCommandResultSchema, replayed: z95.boolean() }).strict();
+var programGoalOptionsQuerySchema = z95.object({ programCode: businessCodeSchema, goalId: z95.string().min(1).max(64).optional() }).strict();
 
 // packages/contracts/src/editorial-collaboration.ts
-import { z as z95 } from "zod";
-var editorialProposalCommandSchema = z95.discriminatedUnion("kind", [
-  z95.object({
-    kind: z95.literal("CANDIDATE"),
-    requestId: z95.uuid(),
+import { z as z96 } from "zod";
+var editorialProposalCommandSchema = z96.discriminatedUnion("kind", [
+  z96.object({
+    kind: z96.literal("CANDIDATE"),
+    requestId: z96.uuid(),
     content: createEditorialCandidateInputSchema.omit({ projectId: true, requestId: true }).strict()
   }).strict(),
-  z95.object({
-    kind: z95.literal("KERNEL"),
-    requestId: z95.uuid(),
+  z96.object({
+    kind: z96.literal("KERNEL"),
+    requestId: z96.uuid(),
     candidateRef: cfRefSchema,
-    expectedReviewSha256: z95.string().regex(/^[a-f0-9]{64}$/),
+    expectedReviewSha256: z96.string().regex(/^[a-f0-9]{64}$/),
     content: createContentKernelInputSchema.omit({ candidateId: true, requestId: true }).strict()
   }).strict()
 ]);
-var editorialReadQuerySchema = z95.object({
+var editorialReadQuerySchema = z96.object({
   kind: editorialKindSchema,
-  limit: z95.coerce.number().int().min(1).max(100).default(12),
-  cursor: z95.string().max(2048).optional(),
-  status: z95.string().max(40).optional()
-}).strict();
-var editorialReadSchema = z95.object({ kind: editorialKindSchema, ref: cfRefSchema }).strict();
-var editorialDecisionCommandSchema = z95.discriminatedUnion("kind", [
-  z95.object({
-    kind: z95.literal("CANDIDATE"),
+  limit: z96.coerce.number().int().min(1).max(100).default(12),
+  cursor: z96.string().max(2048).optional(),
+  status: z96.string().max(40).optional()
+}).strict();
+var editorialReadSchema = z96.object({ kind: editorialKindSchema, ref: cfRefSchema }).strict();
+var editorialDecisionCommandSchema = z96.discriminatedUnion("kind", [
+  z96.object({
+    kind: z96.literal("CANDIDATE"),
     ref: cfRefSchema,
     command: humanCandidateDecisionSchema,
     humanDecision: humanDecisionDeclarationSchema.optional()
   }).strict(),
-  z95.object({
-    kind: z95.literal("KERNEL"),
+  z96.object({
+    kind: z96.literal("KERNEL"),
     ref: cfRefSchema,
     command: humanKernelReviewSchema,
     humanDecision: humanDecisionDeclarationSchema.optional()
   }).strict()
 ]);
-var editorialCommandReceiptQuerySchema = z95.object({ operation: z95.enum(["PROPOSE", "DECIDE"]), requestId: z95.uuid() }).strict();
+var editorialCommandReceiptQuerySchema = z96.object({ operation: z96.enum(["PROPOSE", "DECIDE"]), requestId: z96.uuid() }).strict();
 
 // packages/contracts/src/operating/learning-collaboration.ts
-import { z as z96 } from "zod";
-var humanImprovementProposalSchema = z96.object({
-  requestId: z96.uuid(),
-  observationCodes: z96.array(businessCodeSchema).min(1).max(20),
+import { z as z97 } from "zod";
+var humanImprovementProposalSchema = z97.object({
+  requestId: z97.uuid(),
+  observationCodes: z97.array(businessCodeSchema).min(1).max(20),
   window: feedbackAnalysisRequestInputSchema,
-  expectedBasisFingerprint: z96.string().regex(/^[a-f0-9]{64}$/),
-  kindKey: z96.string().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  title: z96.string().trim().min(1).max(300),
-  summary: z96.string().trim().min(1).max(4e3),
-  rationale: z96.string().trim().min(1).max(8e3),
-  proposedChange: z96.string().trim().min(1).max(8e3)
-}).strict();
-var improvementListSchema = z96.object({
-  limit: z96.coerce.number().int().min(1).max(50).default(12),
-  cursor: z96.string().max(2048).optional(),
-  q: z96.string().max(160).optional(),
+  expectedBasisFingerprint: z97.string().regex(/^[a-f0-9]{64}$/),
+  kindKey: z97.string().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  title: z97.string().trim().min(1).max(300),
+  summary: z97.string().trim().min(1).max(4e3),
+  rationale: z97.string().trim().min(1).max(8e3),
+  proposedChange: z97.string().trim().min(1).max(8e3)
+}).strict();
+var improvementListSchema = z97.object({
+  limit: z97.coerce.number().int().min(1).max(50).default(12),
+  cursor: z97.string().max(2048).optional(),
+  q: z97.string().max(160).optional(),
   status: operatingRecommendationStatusSchema.optional(),
-  queue: z96.enum(["PENDING", "DECIDED"]).optional()
+  queue: z97.enum(["PENDING", "DECIDED"]).optional()
 }).strict().refine((q) => !(q.status && q.queue), "Select an exact status or a queue.");
 var improvementDecisionSchema = operatingRecommendationHumanDecisionSchema.safeExtend({
   recommendationCode: businessCodeSchema,
   humanDecision: humanDecisionDeclarationSchema.optional()
 });
 var packageReviewFeedbackSchema = packageReviewObservationCommandSchema.extend({ packageCode: businessCodeSchema }).strict();
-var publicationObservationBodySchema = z96.object({
-  requestId: z96.uuid(),
-  observedAt: z96.string().datetime({ offset: true }).transform((v) => new Date(v).toISOString()),
+var publicationObservationBodySchema = z97.object({
+  requestId: z97.uuid(),
+  observedAt: z97.string().datetime({ offset: true }).transform((v) => new Date(v).toISOString()),
   metricWindow: feedbackMetricWindowSchema.default("SNAPSHOT"),
-  periodStart: z96.string().datetime({ offset: true }).transform((v) => new Date(v).toISOString()).nullable().default(null),
-  periodEnd: z96.string().datetime({ offset: true }).transform((v) => new Date(v).toISOString()).nullable().default(null),
+  periodStart: z97.string().datetime({ offset: true }).transform((v) => new Date(v).toISOString()).nullable().default(null),
+  periodEnd: z97.string().datetime({ offset: true }).transform((v) => new Date(v).toISOString()).nullable().default(null),
   metrics: feedbackMetricsSchema.default({}),
   facts: feedbackFactsSchema.default({}),
-  note: z96.string().trim().max(8192).nullable().default(null)
+  note: z97.string().trim().max(8192).nullable().default(null)
 }).strict().superRefine((q, ctx) => {
   refineFeedbackMeasurementWindow(q, ctx);
   if (!Object.keys(q.metrics).length && !Object.keys(q.facts).length && !q.note)
@@ -6691,8 +6784,8 @@ var publicationObservationBodySchema = z96.object({
 var publicationObservationCommandSchema = publicationObservationBodySchema.safeExtend({
   publicationCode: businessCodeSchema
 });
-var learningReceiptSchema = z96.object({
-  operation: z96.enum([
+var learningReceiptSchema = z97.object({
+  operation: z97.enum([
     "DECISION",
     "PACKAGE_OBSERVATION",
     "PUBLICATION_OBSERVATION",
@@ -6700,101 +6793,101 @@ var learningReceiptSchema = z96.object({
     "REVIEW_PROPOSAL",
     "HUMAN_PROPOSAL"
   ]),
-  requestId: z96.string().min(1).max(160)
+  requestId: z97.string().min(1).max(160)
 }).strict();
-var strategyLearningReadSchema = z96.object({ recommendationCodes: z96.array(businessCodeSchema).min(1).max(20) }).strict();
-var learningFeedbackCommandSchema = z96.discriminatedUnion("operation", [
-  packageReviewFeedbackSchema.extend({ operation: z96.literal("PACKAGE_OBSERVATION") }),
+var strategyLearningReadSchema = z97.object({ recommendationCodes: z97.array(businessCodeSchema).min(1).max(20) }).strict();
+var learningFeedbackCommandSchema = z97.discriminatedUnion("operation", [
+  packageReviewFeedbackSchema.extend({ operation: z97.literal("PACKAGE_OBSERVATION") }),
   publicationObservationCommandSchema.safeExtend({
-    operation: z96.literal("PUBLICATION_OBSERVATION")
+    operation: z97.literal("PUBLICATION_OBSERVATION")
   })
 ]);
-var publicationObservationReceiptSchema = z96.object({
+var publicationObservationReceiptSchema = z97.object({
   observationCode: businessCodeSchema,
-  observedAt: z96.string().datetime(),
-  sourceMode: z96.literal("HUMAN"),
+  observedAt: z97.string().datetime(),
+  sourceMode: z97.literal("HUMAN"),
   publicationCode: businessCodeSchema
 }).strict();
 
 // packages/contracts/src/access/administration.ts
-import { z as z97 } from "zod";
-var command4 = { requestId: z97.uuid(), humanDecision: humanDecisionDeclarationSchema.optional() };
-var tenantRoleSchema = z97.enum(["TENANT_OWNER", "TENANT_ADMIN"]).nullable();
-var teamListSchema = z97.object({
-  limit: z97.coerce.number().int().min(1).max(50).default(12),
-  cursor: z97.string().max(2048).optional(),
-  q: z97.string().max(160).optional(),
-  status: z97.enum(["ACTIVE", "INACTIVE"]).optional()
-}).strict();
-var teamMemberReadSchema = z97.object({
+import { z as z98 } from "zod";
+var command4 = { requestId: z98.uuid(), humanDecision: humanDecisionDeclarationSchema.optional() };
+var tenantRoleSchema = z98.enum(["TENANT_OWNER", "TENANT_ADMIN"]).nullable();
+var teamListSchema = z98.object({
+  limit: z98.coerce.number().int().min(1).max(50).default(12),
+  cursor: z98.string().max(2048).optional(),
+  q: z98.string().max(160).optional(),
+  status: z98.enum(["ACTIVE", "INACTIVE"]).optional()
+}).strict();
+var teamMemberReadSchema = z98.object({
   userCode: businessCodeSchema,
-  includeBusiness: z97.boolean().default(false),
+  includeBusiness: z98.boolean().default(false),
   businessKind: memberBusinessKindSchema.optional(),
-  businessCursor: z97.string().min(1).max(2048).optional()
+  businessCursor: z98.string().min(1).max(2048).optional()
 }).strict().refine(
   (v) => (!v.businessKind || v.includeBusiness) && (!v.businessCursor || Boolean(v.businessKind)),
   { message: "Business pagination requires includeBusiness and an exact businessKind." }
 );
-var teamRegisterSchema = z97.object({
+var teamRegisterSchema = z98.object({
   ...command4,
-  email: z97.string().trim().email().max(320),
-  displayName: z97.string().trim().min(1).max(160),
+  email: z98.string().trim().email().max(320),
+  displayName: z98.string().trim().min(1).max(160),
   roleTemplate: tenantRoleSchema.default(null)
 }).strict();
-var teamUpdateSchema = z97.object({
+var teamUpdateSchema = z98.object({
   ...command4,
   userCode: businessCodeSchema,
-  expectedSha256: z97.string().regex(/^[a-f0-9]{64}$/),
-  displayName: z97.string().trim().min(1).max(160).optional(),
+  expectedSha256: z98.string().regex(/^[a-f0-9]{64}$/),
+  displayName: z98.string().trim().min(1).max(160).optional(),
   roleTemplate: tenantRoleSchema.optional()
 }).strict().refine((v) => v.displayName !== void 0 || v.roleTemplate !== void 0, {
   message: "Choose a name or company role to update."
 });
-var teamDeactivateSchema = z97.object({
+var teamDeactivateSchema = z98.object({
   ...command4,
   userCode: businessCodeSchema,
-  expectedSha256: z97.string().regex(/^[a-f0-9]{64}$/)
+  expectedSha256: z98.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var projectAccessReadSchema = z97.object({ projectCode: businessCodeSchema, userCode: businessCodeSchema }).strict();
+var projectAccessReadSchema = z98.object({ projectCode: businessCodeSchema, userCode: businessCodeSchema }).strict();
 var projectAccessCommandSchema = projectAccessChangeSchema.extend({ ...command4, ...projectAccessReadSchema.shape }).strict();
-var administrationReceiptSchema = z97.object({
-  operation: z97.enum(["REGISTER", "UPDATE", "DEACTIVATE", "PROJECT_ACCESS"]),
-  requestId: z97.uuid()
+var administrationReceiptSchema = z98.object({
+  operation: z98.enum(["REGISTER", "UPDATE", "DEACTIVATE", "PROJECT_ACCESS"]),
+  requestId: z98.uuid()
 }).strict();
-var administrationMemberSchema = z97.object({
-  user: z97.object({
+var administrationMemberSchema = z98.object({
+  user: z98.object({
     businessCode: businessCodeSchema,
-    email: z97.string(),
-    displayName: z97.string(),
-    status: z97.enum(["ACTIVE", "DISABLED"])
+    email: z98.string(),
+    displayName: z98.string(),
+    status: z98.enum(["ACTIVE", "DISABLED"])
   }),
-  status: z97.enum(["ACTIVE", "INACTIVE"]),
-  roleTemplate: z97.string().nullable(),
-  deactivatedAt: z97.string().datetime().nullable(),
-  canManage: z97.boolean(),
-  canEditDisplayName: z97.boolean(),
-  canChangeRole: z97.boolean().optional(),
-  canViewBusiness: z97.boolean().optional(),
-  business: z97.null().optional(),
-  baselineSha256: z97.string(),
-  credentialSetupRequired: z97.boolean(),
-  credentialSetupHref: z97.string().nullable()
+  status: z98.enum(["ACTIVE", "INACTIVE"]),
+  roleTemplate: z98.string().nullable(),
+  deactivatedAt: z98.string().datetime().nullable(),
+  canManage: z98.boolean(),
+  canEditDisplayName: z98.boolean(),
+  canChangeRole: z98.boolean().optional(),
+  canViewBusiness: z98.boolean().optional(),
+  business: z98.null().optional(),
+  baselineSha256: z98.string(),
+  credentialSetupRequired: z98.boolean(),
+  credentialSetupHref: z98.string().nullable()
 }).strict();
 var administrationMemberReadSchema = administrationMemberSchema.extend({
   business: memberBusinessViewSchema.nullable().optional()
 });
-var administrationConfigurationSchema = z97.object({
-  limit: z97.coerce.number().int().min(1).max(20).default(8),
-  cursor: z97.string().max(2048).optional()
+var administrationConfigurationSchema = z98.object({
+  limit: z98.coerce.number().int().min(1).max(20).default(8),
+  cursor: z98.string().max(2048).optional()
 }).strict();
-var administrationBrowserCommandSchema = z97.discriminatedUnion("operation", [
-  teamRegisterSchema.extend({ operation: z97.literal("REGISTER") }),
-  teamUpdateSchema.safeExtend({ operation: z97.literal("UPDATE") }),
-  teamDeactivateSchema.extend({ operation: z97.literal("DEACTIVATE") }),
-  projectAccessCommandSchema.extend({ operation: z97.literal("PROJECT_ACCESS") })
+var administrationBrowserCommandSchema = z98.discriminatedUnion("operation", [
+  teamRegisterSchema.extend({ operation: z98.literal("REGISTER") }),
+  teamUpdateSchema.safeExtend({ operation: z98.literal("UPDATE") }),
+  teamDeactivateSchema.extend({ operation: z98.literal("DEACTIVATE") }),
+  projectAccessCommandSchema.extend({ operation: z98.literal("PROJECT_ACCESS") })
 ]);
 var administrationProjectReceiptSchema = administrationReceiptSchema.extend({
-  operation: z97.literal("PROJECT_ACCESS")
+  operation: z98.literal("PROJECT_ACCESS")
 });
 
 // packages/contracts/src/agent/capability-recovery.ts
@@ -6916,70 +7009,232 @@ function capabilityRecovery(code2, outcome, name) {
 }
 
 // packages/contracts/src/event-exchange.ts
+import { z as z101 } from "zod";
+
+// packages/contracts/src/event-exchange-browser.ts
 import { z as z99 } from "zod";
 
+// packages/contracts/src/generated/eventsdk-exchange-registration.ts
+var eventSdkExchangeRegistrationJsonSchema = {
+  title: "ExchangeRegistration",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schemaVersion",
+    "requestId",
+    "expectedRevision",
+    "source",
+    "target",
+    "grant",
+    "status"
+  ],
+  properties: {
+    schemaVersion: {
+      const: 1
+    },
+    requestId: {
+      type: "string",
+      minLength: 1,
+      maxLength: 256,
+      pattern: "^[^\\u0000-\\u0020\\u007f]+$"
+    },
+    expectedRevision: {
+      type: ["integer", "null"],
+      minimum: 1,
+      maximum: 2147483647
+    },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["source", "serviceRef", "tenantRef", "issuer", "subject"],
+      properties: {
+        source: {
+          type: "string",
+          format: "uri",
+          maxLength: 2048
+        },
+        serviceRef: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          pattern: "^[^\\u0000-\\u0020\\u007f]+$"
+        },
+        tenantRef: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          pattern: "^[^\\u0000-\\u0020\\u007f]+$"
+        },
+        issuer: {
+          type: "string",
+          format: "uri",
+          maxLength: 2048
+        },
+        subject: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          pattern: "^[^\\u0000-\\u0020\\u007f]+$"
+        }
+      }
+    },
+    target: {
+      title: "TenantContext",
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        serviceRef: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+        },
+        tenantRef: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+        }
+      },
+      required: ["serviceRef", "tenantRef"]
+    },
+    grant: {
+      type: "object",
+      additionalProperties: false,
+      required: ["grantRef", "version", "eventType", "consumerRef"],
+      properties: {
+        grantRef: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          pattern: "^[^\\u0000-\\u0020\\u007f]+$"
+        },
+        version: {
+          type: "integer",
+          minimum: 1,
+          maximum: 2147483647
+        },
+        eventType: {
+          type: "string",
+          pattern: "^[A-Za-z0-9][A-Za-z0-9._-]*\\.v[1-9][0-9]*$",
+          maxLength: 256
+        },
+        consumerRef: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          pattern: "^[^\\u0000-\\u0020\\u007f]+$"
+        }
+      }
+    },
+    status: {
+      enum: ["ACTIVE", "REVOKED"]
+    }
+  }
+};
+
 // packages/contracts/src/event-exchange-browser.ts
-import { z as z98 } from "zod";
-var ref2 = z98.string().min(1).max(2048);
-var eventExchangeSourceSchema = z98.object({ source: ref2, serviceRef: ref2, tenantRef: ref2, issuer: ref2, subject: ref2 }).strict();
-var eventExchangeTargetSchema = z98.object({ serviceRef: ref2, tenantRef: ref2 }).strict();
-var eventExchangeBrowserCommandSchema = z98.object({
-  schemaVersion: z98.literal(1),
-  requestId: z98.string().min(1).max(256),
-  expectedRevision: z98.number().int().positive().nullable(),
+var ref2 = z99.string().min(1).max(2048);
+var eventExchangeSourceSchema = z99.object({ source: ref2, serviceRef: ref2, tenantRef: ref2, issuer: ref2, subject: ref2 }).strict();
+var eventExchangeTargetSchema = z99.object({ serviceRef: ref2, tenantRef: ref2 }).strict();
+var eventExchangeBrowserCommandSchema = z99.object({
+  schemaVersion: z99.literal(1),
+  requestId: z99.string().min(1).max(256),
+  expectedRevision: z99.number().int().positive().nullable(),
   source: eventExchangeSourceSchema,
   target: eventExchangeTargetSchema,
-  grant: z98.object({
-    grantRef: z98.string().min(1).max(256),
-    version: z98.number().int().positive(),
-    eventType: z98.string().min(1).max(256),
+  grant: z99.object({
+    grantRef: z99.string().min(1).max(256),
+    version: z99.number().int().positive(),
+    eventType: z99.string().min(1).max(256),
     consumerRef: ref2
   }).strict(),
-  status: z98.enum(["ACTIVE", "REVOKED"])
+  status: z99.enum(["ACTIVE", "REVOKED"])
 }).strict();
+var eventExchangeSubmissionSchema = z99.fromJSONSchema(
+  structuredClone(eventSdkExchangeRegistrationJsonSchema)
+).pipe(eventExchangeBrowserCommandSchema);
 
-// packages/contracts/src/event-exchange.ts
-var eventExchangePageQuerySchema = z99.object({
-  after: z99.string().max(256).default(""),
-  limit: z99.number().int().min(1).max(100).default(50)
+// packages/contracts/src/event-readiness.ts
+import { z as z100 } from "zod";
+var eventReadinessIssueSchema = z100.enum([
+  "PROFILE_NOT_CONFIGURED",
+  "PROFILE_UNAVAILABLE",
+  "PROFILE_NOT_ACTIVE",
+  "LOCAL_AUTHORIZATION_INACTIVE",
+  "BINDING_UNAVAILABLE",
+  "GRANTS_TRUNCATED",
+  "PUBLISHER_NOT_CONFIGURED",
+  "SIGNER_NOT_CONFIGURED",
+  "INSTALLATION_SOURCE_MISMATCH",
+  "SIGNER_IDENTITY_MISMATCH",
+  "AUDIENCE_NOT_CONFIGURED",
+  "OWN_PUBLIC_IDENTITY_UNAVAILABLE",
+  "CONSUMER_NOT_CONFIGURED",
+  "CONSUMER_REF_MISMATCH",
+  "SOURCE_NOT_TRUSTED",
+  "SOURCE_TRUST_UNAVAILABLE"
+]);
+var eventRuntimeConfigurationSchema = z100.object({
+  schemaVersion: z100.literal(1),
+  status: z100.enum(["NOT_CONFIGURED", "VALID", "UNAVAILABLE"]),
+  mode: z100.enum(["DISABLED", "SHADOW", "ACTIVE"]).nullable(),
+  publisherConfigured: z100.boolean(),
+  consumerConfigured: z100.boolean(),
+  workerConfiguration: z100.enum(["MATCHED", "DIFFERENT", "NOT_OBSERVED"]),
+  checkedAt: z100.string().datetime()
 }).strict();
-var eventExchangeReceiptQuerySchema = z99.object({ requestId: z99.string().min(1).max(256) }).strict();
-var knowledgeRefreshRevisionSchema = z99.object({
-  schemaVersion: z99.literal(1),
-  revision: z99.string().regex(/^\d+$/),
-  recordedAt: z99.string().datetime().nullable(),
-  baselines: z99.array(
-    z99.object({
-      connectionRef: z99.string(),
-      source: z99.string(),
-      baselineRef: z99.string(),
-      watermark: z99.string().regex(/^\d+$/),
-      sourceRevision: z99.string()
+var eventConnectionReadinessSchema = z100.object({
+  state: z100.enum(["CONFIGURED", "PARTIAL", "BLOCKED", "UNAVAILABLE"]),
+  issues: z100.array(eventReadinessIssueSchema).max(20),
+  blockedEventTypes: z100.array(z100.string().max(256)).max(100),
+  peerConsent: z100.literal("NOT_OBSERVED"),
+  checkedAt: z100.string().datetime()
+}).strict();
+
+// packages/contracts/src/event-exchange.ts
+var eventExchangePageQuerySchema = z101.object({
+  after: z101.string().max(256).default(""),
+  limit: z101.number().int().min(1).max(100).default(50)
+}).strict();
+var eventExchangeReceiptQuerySchema = z101.object({ requestId: z101.string().min(1).max(256) }).strict();
+var knowledgeRefreshRevisionSchema = z101.object({
+  schemaVersion: z101.literal(1),
+  revision: z101.string().regex(/^\d+$/),
+  recordedAt: z101.string().datetime().nullable(),
+  baselines: z101.array(
+    z101.object({
+      connectionRef: z101.string(),
+      source: z101.string(),
+      baselineRef: z101.string(),
+      watermark: z101.string().regex(/^\d+$/),
+      sourceRevision: z101.string()
     }).strict()
   ).max(100).default([]),
-  baselinesTruncated: z99.boolean().default(false)
-}).strict();
-var exchangeStatus = z99.enum(["ACTIVE", "REVOKED"]);
-var direction = z99.enum(["OUTBOUND", "RECEIVE"]);
-var eventExchangeResultSchema = z99.object({
-  schemaVersion: z99.literal(1),
-  connectionRef: z99.string().regex(/^urn:eventsdk:connection:[a-f0-9]{64}$/),
-  revision: z99.number().int().positive(),
+  baselinesTruncated: z101.boolean().default(false)
+}).strict();
+var exchangeStatus = z101.enum(["ACTIVE", "REVOKED"]);
+var direction = z101.enum(["OUTBOUND", "RECEIVE"]);
+var eventExchangeResultSchema = z101.object({
+  schemaVersion: z101.literal(1),
+  connectionRef: z101.string().regex(/^urn:eventsdk:connection:[a-f0-9]{64}$/),
+  revision: z101.number().int().positive(),
   direction,
   status: exchangeStatus,
-  grantRef: z99.string().min(1).max(256),
-  grantVersion: z99.number().int().positive(),
-  eventType: z99.string().optional()
+  grantRef: z101.string().min(1).max(256),
+  grantVersion: z101.number().int().positive(),
+  eventType: z101.string().optional()
 }).strict();
-var eventExchangeReceiptSchema = z99.object({
-  schemaVersion: z99.literal(1),
-  requestId: z99.string().min(1).max(256),
+var eventExchangeReceiptSchema = z101.object({
+  schemaVersion: z101.literal(1),
+  requestId: z101.string().min(1).max(256),
   result: eventExchangeResultSchema.nullable()
 }).strict();
-var eventExchangePageSchema = z99.object({
-  schemaVersion: z99.literal(1),
+var eventExchangePageSchema = z101.object({
+  schemaVersion: z101.literal(1),
   localTenant: eventExchangeTargetSchema.optional(),
-  items: z99.array(
+  runtimeConfiguration: eventRuntimeConfigurationSchema.optional(),
+  items: z101.array(
     eventExchangeResultSchema.pick({
       connectionRef: true,
       revision: true,
@@ -6988,13 +7243,14 @@ var eventExchangePageSchema = z99.object({
     }).extend({
       source: eventExchangeSourceSchema.optional(),
       target: eventExchangeTargetSchema.optional(),
-      grantsTruncated: z99.boolean().optional(),
-      grants: z99.array(
-        z99.object({
-          eventType: z99.string(),
-          grantRef: z99.string(),
-          grantVersion: z99.number().int().positive(),
-          consumerRef: z99.string().optional(),
+      grantsTruncated: z101.boolean().optional(),
+      readiness: eventConnectionReadinessSchema.optional(),
+      grants: z101.array(
+        z101.object({
+          eventType: z101.string(),
+          grantRef: z101.string(),
+          grantVersion: z101.number().int().positive(),
+          consumerRef: z101.string().optional(),
           source: eventExchangeSourceSchema.optional(),
           target: eventExchangeTargetSchema.optional(),
           status: exchangeStatus
@@ -7002,78 +7258,7 @@ var eventExchangePageSchema = z99.object({
       ).max(100).optional()
     })
   ).max(100),
-  nextAfter: z99.string().max(256).nullable()
-}).strict();
-
-// packages/contracts/src/knowledge-discovery.ts
-import { z as z100 } from "zod";
-var knowledgeRemoteRefSchema = z100.string().min(1).max(4096).refine((value) => {
-  try {
-    const url = new URL(value);
-    return !url.username && !url.password && /^[a-z][a-z0-9+.-]*:$/.test(url.protocol);
-  } catch {
-    return false;
-  }
-});
-var knowledgeDiscoveryQuerySchema = z100.object({
-  q: z100.string().trim().min(2).max(160).optional(),
-  cursor: z100.string().min(1).max(8192).optional(),
-  resourceType: z100.string().regex(/^[a-z][a-z0-9._-]{0,63}$/).optional(),
-  limit: z100.number().int().min(1).max(50).default(20)
-}).strict();
-var knowledgeDiscoveryReadQuerySchema = z100.object({
-  ref: knowledgeRemoteRefSchema,
-  expectedContentHash: z100.string().regex(/^sha256:[a-f0-9]{64}$/).optional()
-}).strict();
-var knowledgeDiscoveryItemSchema = z100.object({
-  ref: knowledgeRemoteRefSchema,
-  ownerTenantId: z100.string().min(1).max(256),
-  resourceType: z100.string().min(1).max(128),
-  originType: z100.enum(["LEGACY_PROJECT", "TENANT_AUTHOR", "TENANT_SOURCE"]),
-  identityHash: z100.string().regex(/^sha256:[a-f0-9]{64}$/),
-  identityKind: z100.enum(["CAS_BYTES", "REFERENCE_RECORD_DIGEST"]),
-  kind: z100.string().min(1).max(128),
-  classification: z100.string().max(128),
-  mediaType: z100.string().min(1).max(256),
-  title: z100.string().max(512),
-  summary: z100.string().max(1024),
-  readable: z100.boolean(),
-  reasonCodes: z100.array(z100.string().max(128)).max(32)
-});
-var knowledgeDiscoveryPageSchema = z100.object({
-  schemaVersion: z100.literal(1),
-  sourceTenantId: z100.string().min(1).max(256),
-  items: z100.array(knowledgeDiscoveryItemSchema).max(50),
-  pageInfo: z100.object({ nextCursor: z100.string().max(8192).nullable() }).strict(),
-  coverage: z100.enum(["CURRENT_AUTHORIZED_DIRECTORY", "INDEXED_DESCRIPTIONS_ONLY"]),
-  checkedAt: z100.string().datetime()
-}).strict();
-var knowledgeDiscoveryReadSchema = z100.object({
-  schemaVersion: z100.literal(1),
-  sourceTenantId: z100.string().min(1).max(256),
-  item: knowledgeDiscoveryItemSchema,
-  contentHash: z100.string().regex(/^sha256:[a-f0-9]{64}$/),
-  mediaType: z100.string().min(1).max(256),
-  byteLength: z100.number().int().min(0).max(524288),
-  content: z100.string().max(524288),
-  verified: z100.literal(true),
-  checkedAt: z100.string().datetime()
-}).strict();
-var knowledgeAdoptionCommandSchema = knowledgeDiscoveryReadQuerySchema.required().extend({
-  requestId: z100.string().min(1).max(128)
-}).strict();
-var knowledgeAdoptionResultSchema = z100.object({ result: sourceRefSchema, replayed: z100.boolean() }).strict();
-var knowledgeAdoptionReceiptQuerySchema = z100.object({ requestId: z100.string().min(1).max(128) }).strict();
-var knowledgeAdoptionReceiptSchema = z100.discriminatedUnion("state", [
-  z100.object({ state: z100.literal("FOUND"), result: sourceRefSchema }).strict(),
-  z100.object({ state: z100.literal("NOT_FOUND"), result: z100.null() }).strict(),
-  commandRejectedReceiptSchema
-]);
-var adoptedKnowledgeResourceSchema = z100.object({
-  schemaVersion: z100.literal(1),
-  sourceTenantId: z100.string().min(1).max(256),
-  ref: knowledgeRemoteRefSchema,
-  identityHash: z100.string().regex(/^sha256:[a-f0-9]{64}$/)
+  nextAfter: z101.string().max(256).nullable()
 }).strict();
 
 // packages/contracts/src/agent/capability-receipts.ts
@@ -7320,7 +7505,7 @@ function capabilityReceiptRead(name, input) {
 }
 
 // packages/contracts/src/agent/capability-status.ts
-import { z as z101 } from "zod";
+import { z as z102 } from "zod";
 var verification = {
   capability: "cf_material_verification_status",
   schema: materialVerificationIdSchema,
@@ -7338,7 +7523,7 @@ var rules2 = {
   },
   cf_tenant_material_scan_advance: {
     capability: "cf_tenant_material_scan_status",
-    schema: z101.object({}).strict()
+    schema: z102.object({}).strict()
   },
   cf_sync_materials: {
     capability: "cf_reconcile_materials",
@@ -9044,6 +9229,7 @@ var taskTools = {
 var commandTools = {
   "feedback metrics": "cf_get_feedback_metrics",
   context: "cf_get_work_context",
+  "review asset": "cf_get_review_asset",
   // 任务发起/对账使用同一MCP应用服务，不在CLI复制任务或修订规则。
   "task start": "cf_start_task",
   "task status": "cf_get_task_status",
@@ -9069,6 +9255,7 @@ var commandTools = {
   "knowledge adopt": "cf_adopt_discovered_knowledge",
   "knowledge adoption-receipt": "cf_get_knowledge_adoption_receipt",
   "knowledge read-discovered": "cf_read_discovered_knowledge",
+  "knowledge describe-discovered": "cf_describe_discovered_knowledge",
   "knowledge materials": "cf_list_materials",
   "knowledge topics": "cf_list_material_topics",
   "knowledge read": "cf_read_knowledge",
@@ -9083,6 +9270,8 @@ var commandTools = {
   "event-exchanges outbox-list": "cf_list_event_outbox",
   "event-exchanges outbox-recover": "cf_recover_event_outbox",
   "event-exchanges outbox-receipt": "cf_get_event_outbox_recovery_receipt",
+  "event-exchanges inbox-list": "cf_list_event_inbox",
+  "event-exchanges inbox-receipt": "cf_get_event_inbox_receipt",
   "knowledge verify-start": "cf_material_verification_start",
   "knowledge verify-status": "cf_material_verification_status",
   "knowledge verify-advance": "cf_material_verification_advance",