@treeseed/sdk 0.13.0-rc.64 → 0.13.0-rc.65

package/dist/content/validation/portable-content-data.d.ts

@@ -214,8 +214,8 @@ export declare function validatePortableContentData(model: string, value: unknow
                     value?: unknown;
                 }>>>;
             }, "strict", import("zod").ZodTypeAny, {
-                capabilityId: string;
                 requirement: "required" | "preferred";
+                capabilityId: string;
                 versionRange: string;
                 configuration?: Record<string, {
                     requirement: "required" | "preferred";
@@ -224,8 +224,8 @@ export declare function validatePortableContentData(model: string, value: unknow
                 alternativeGroup?: string | null | undefined;
                 requiredFeatures?: string[] | undefined;
             }, {
-                capabilityId: string;
                 requirement: "required" | "preferred";
+                capabilityId: string;
                 versionRange: string;
                 configuration?: Record<string, {
                     requirement: "required" | "preferred";
@@ -902,8 +902,8 @@ export declare function validatePortableContentData(model: string, value: unknow
                 revision: number;
             }[] | undefined;
             capabilityRequirements?: {
-                capabilityId: string;
                 requirement: "required" | "preferred";
+                capabilityId: string;
                 versionRange: string;
                 configuration?: Record<string, {
                     requirement: "required" | "preferred";
@@ -1074,8 +1074,8 @@ export declare function validatePortableContentData(model: string, value: unknow
                 revision: number;
             }[] | undefined;
             capabilityRequirements?: {
-                capabilityId: string;
                 requirement: "required" | "preferred";
+                capabilityId: string;
                 versionRange: string;
                 configuration?: Record<string, {
                     requirement: "required" | "preferred";
@@ -1246,8 +1246,8 @@ export declare function validatePortableContentData(model: string, value: unknow
                 revision: number;
             }[] | undefined;
             capabilityRequirements?: {
-                capabilityId: string;
                 requirement: "required" | "preferred";
+                capabilityId: string;
                 versionRange: string;
                 configuration?: Record<string, {
                     requirement: "required" | "preferred";
@@ -1418,8 +1418,8 @@ export declare function validatePortableContentData(model: string, value: unknow
                 revision: number;
             }[] | undefined;
             capabilityRequirements?: {
-                capabilityId: string;
                 requirement: "required" | "preferred";
+                capabilityId: string;
                 versionRange: string;
                 configuration?: Record<string, {
                     requirement: "required" | "preferred";

package/dist/deployment/schemas.d.ts

@@ -3961,6 +3961,117 @@ export declare const componentReleaseSchema: z.ZodEffects<z.ZodObject<{
         vulnerabilities: string[];
     };
 }>;
+export declare const hostInitializationProfileSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.host-initialization-profile/v1">;
+    id: z.ZodString;
+    role: z.ZodUnion<[z.ZodEnum<["integrated", "capacity-provider", "control-plane", "knowledge", "ai-gpu", "edge"]>, z.ZodString]>;
+    runtime: z.ZodObject<{
+        management: z.ZodLiteral<"managed">;
+        environment: z.ZodEnum<["track-default", "production", "development"]>;
+    }, "strict", z.ZodTypeAny, {
+        environment: "development" | "production" | "track-default";
+        management: "managed";
+    }, {
+        environment: "development" | "production" | "track-default";
+        management: "managed";
+    }>;
+    components: z.ZodArray<z.ZodString, "many">;
+    security: z.ZodObject<{
+        requirement: z.ZodEnum<["required", "optional", "none"]>;
+    }, "strict", z.ZodTypeAny, {
+        requirement: "required" | "none" | "optional";
+    }, {
+        requirement: "required" | "none" | "optional";
+    }>;
+    inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        required: z.ZodBoolean;
+        sensitive: z.ZodBoolean;
+        description: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+        description: string;
+    }, {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+        description: string;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    role: string;
+    schemaVersion: "treeseed.host-initialization-profile/v1";
+    id: string;
+    runtime: {
+        environment: "development" | "production" | "track-default";
+        management: "managed";
+    };
+    components: string[];
+    inputs: {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+        description: string;
+    }[];
+    security: {
+        requirement: "required" | "none" | "optional";
+    };
+}, {
+    role: string;
+    schemaVersion: "treeseed.host-initialization-profile/v1";
+    id: string;
+    runtime: {
+        environment: "development" | "production" | "track-default";
+        management: "managed";
+    };
+    components: string[];
+    security: {
+        requirement: "required" | "none" | "optional";
+    };
+    inputs?: {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+        description: string;
+    }[] | undefined;
+}>, {
+    role: string;
+    schemaVersion: "treeseed.host-initialization-profile/v1";
+    id: string;
+    runtime: {
+        environment: "development" | "production" | "track-default";
+        management: "managed";
+    };
+    components: string[];
+    inputs: {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+        description: string;
+    }[];
+    security: {
+        requirement: "required" | "none" | "optional";
+    };
+}, {
+    role: string;
+    schemaVersion: "treeseed.host-initialization-profile/v1";
+    id: string;
+    runtime: {
+        environment: "development" | "production" | "track-default";
+        management: "managed";
+    };
+    components: string[];
+    security: {
+        requirement: "required" | "none" | "optional";
+    };
+    inputs?: {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+        description: string;
+    }[] | undefined;
+}>;
 export declare const integrationReleaseSchema: z.ZodEffects<z.ZodObject<{
     schemaVersion: z.ZodLiteral<"treeseed.integration-release/v1">;
     release: z.ZodString;
@@ -4021,6 +4132,31 @@ export declare const integrationReleaseSchema: z.ZodEffects<z.ZodObject<{
         };
         packageName: string;
     }>, "many">;
+    hostProfiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        artifact: z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sha256: string;
+            url: string;
+        }, {
+            sha256: string;
+            url: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        artifact: {
+            sha256: string;
+            url: string;
+        };
+    }, {
+        id: string;
+        artifact: {
+            sha256: string;
+            url: string;
+        };
+    }>, "many">>;
     components: z.ZodArray<z.ZodObject<{
         componentId: z.ZodString;
         release: z.ZodString;
@@ -4129,6 +4265,13 @@ export declare const integrationReleaseSchema: z.ZodEffects<z.ZodObject<{
         };
         packageName: string;
     }[];
+    hostProfiles: {
+        id: string;
+        artifact: {
+            sha256: string;
+            url: string;
+        };
+    }[];
 }, {
     schemaVersion: "treeseed.integration-release/v1";
     release: string;
@@ -4169,6 +4312,13 @@ export declare const integrationReleaseSchema: z.ZodEffects<z.ZodObject<{
         };
         packageName: string;
     }[];
+    hostProfiles?: {
+        id: string;
+        artifact: {
+            sha256: string;
+            url: string;
+        };
+    }[] | undefined;
 }>, {
     schemaVersion: "treeseed.integration-release/v1";
     release: string;
@@ -4209,6 +4359,13 @@ export declare const integrationReleaseSchema: z.ZodEffects<z.ZodObject<{
         };
         packageName: string;
     }[];
+    hostProfiles: {
+        id: string;
+        artifact: {
+            sha256: string;
+            url: string;
+        };
+    }[];
 }, {
     schemaVersion: "treeseed.integration-release/v1";
     release: string;
@@ -4249,6 +4406,13 @@ export declare const integrationReleaseSchema: z.ZodEffects<z.ZodObject<{
         };
         packageName: string;
     }[];
+    hostProfiles?: {
+        id: string;
+        artifact: {
+            sha256: string;
+            url: string;
+        };
+    }[] | undefined;
 }>;
 export declare const releaseCatalogSchema: z.ZodEffects<z.ZodObject<{
     schemaVersion: z.ZodLiteral<"treeseed.release-catalog/v1">;
@@ -5649,6 +5813,117 @@ export declare const releaseCatalogSchema: z.ZodEffects<z.ZodObject<{
             vulnerabilities: string[];
         };
     }>, "many">;
+    hostProfiles: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"treeseed.host-initialization-profile/v1">;
+        id: z.ZodString;
+        role: z.ZodUnion<[z.ZodEnum<["integrated", "capacity-provider", "control-plane", "knowledge", "ai-gpu", "edge"]>, z.ZodString]>;
+        runtime: z.ZodObject<{
+            management: z.ZodLiteral<"managed">;
+            environment: z.ZodEnum<["track-default", "production", "development"]>;
+        }, "strict", z.ZodTypeAny, {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        }, {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        }>;
+        components: z.ZodArray<z.ZodString, "many">;
+        security: z.ZodObject<{
+            requirement: z.ZodEnum<["required", "optional", "none"]>;
+        }, "strict", z.ZodTypeAny, {
+            requirement: "required" | "none" | "optional";
+        }, {
+            requirement: "required" | "none" | "optional";
+        }>;
+        inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            required: z.ZodBoolean;
+            sensitive: z.ZodBoolean;
+            description: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }, {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        inputs: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+    }, {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+        inputs?: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[] | undefined;
+    }>, {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        inputs: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+    }, {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+        inputs?: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[] | undefined;
+    }>, "many">>;
     createdAt: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     schemaVersion: "treeseed.release-catalog/v1";
@@ -5792,6 +6067,25 @@ export declare const releaseCatalogSchema: z.ZodEffects<z.ZodObject<{
         release: string;
         catalogDigest: string;
     } | null;
+    hostProfiles: {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        inputs: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+    }[];
 }, {
     schemaVersion: "treeseed.release-catalog/v1";
     release: string;
@@ -5934,6 +6228,25 @@ export declare const releaseCatalogSchema: z.ZodEffects<z.ZodObject<{
         release: string;
         catalogDigest: string;
     } | null;
+    hostProfiles?: {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+        inputs?: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[] | undefined;
+    }[] | undefined;
 }>, {
     schemaVersion: "treeseed.release-catalog/v1";
     release: string;
@@ -6076,6 +6389,25 @@ export declare const releaseCatalogSchema: z.ZodEffects<z.ZodObject<{
         release: string;
         catalogDigest: string;
     } | null;
+    hostProfiles: {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        inputs: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+    }[];
 }, {
     schemaVersion: "treeseed.release-catalog/v1";
     release: string;
@@ -6218,6 +6550,25 @@ export declare const releaseCatalogSchema: z.ZodEffects<z.ZodObject<{
         release: string;
         catalogDigest: string;
     } | null;
+    hostProfiles?: {
+        role: string;
+        schemaVersion: "treeseed.host-initialization-profile/v1";
+        id: string;
+        runtime: {
+            environment: "development" | "production" | "track-default";
+            management: "managed";
+        };
+        components: string[];
+        security: {
+            requirement: "required" | "none" | "optional";
+        };
+        inputs?: {
+            name: string;
+            required: boolean;
+            sensitive: boolean;
+            description: string;
+        }[] | undefined;
+    }[] | undefined;
 }>;
 export declare const hostPlanSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"treeseed.host-plan/v1">;
@@ -6712,6 +7063,7 @@ export type PackageEndpoint = z.infer<typeof packageEndpointSchema>;
 export type ComponentRelease = z.infer<typeof componentReleaseSchema>;
 export type ReleaseCatalog = z.infer<typeof releaseCatalogSchema>;
 export type IntegrationRelease = z.infer<typeof integrationReleaseSchema>;
+export type HostInitializationProfile = z.infer<typeof hostInitializationProfileSchema>;
 export type HostPlan = z.infer<typeof hostPlanSchema>;
 export type HostBootstrap = z.infer<typeof hostBootstrapSchema>;
 export type HostUpdate = z.infer<typeof hostUpdateSchema>;

package/dist/deployment/schemas.js

@@ -257,6 +257,25 @@ const componentReleaseSchema = z.object({
   if (release.track === "stable" && release.stableBase) context.addIssue({ code: z.ZodIssueCode.custom, path: ["stableBase"], message: "Stable releases cannot be overlays." });
 });
 const lockedArtifactSchema = z.object({ url: z.string().url(), sha256: z.string().regex(/^[a-f0-9]{64}$/u) }).strict();
+const initializationInputName = z.string().regex(/^[a-z][A-Za-z0-9]{1,63}$/u);
+const hostInitializationProfileSchema = z.object({
+  schemaVersion: z.literal("treeseed.host-initialization-profile/v1"),
+  id: identifier,
+  role: hostRoleSchema,
+  runtime: z.object({ management: z.literal("managed"), environment: z.enum(["track-default", "production", "development"]) }).strict(),
+  components: z.array(identifier).min(1),
+  security: z.object({ requirement: z.enum(["required", "optional", "none"]) }).strict(),
+  inputs: z.array(z.object({
+    name: initializationInputName,
+    required: z.boolean(),
+    sensitive: z.boolean(),
+    description: z.string().min(1).max(512)
+  }).strict()).default([])
+}).strict().superRefine((profile, context) => {
+  for (const [path, values] of [["components", profile.components], ["inputs", profile.inputs.map(({ name }) => name)]]) {
+    if (new Set(values).size !== values.length) context.addIssue({ code: z.ZodIssueCode.custom, path: [path], message: `Host initialization profile ${path} must be unique.` });
+  }
+});
 const integrationReleaseSchema = z.object({
   schemaVersion: z.literal("treeseed.integration-release/v1"),
   release: packageVersion,
@@ -266,6 +285,7 @@ const integrationReleaseSchema = z.object({
   platform: z.object({ repository: z.literal("treeseed-ai/platform"), commit: gitCommit }).strict(),
   deployment: z.object({ repository: z.literal("treeseed-ai/deployment"), commit: gitCommit, tag: z.string().min(1) }).strict(),
   hostPayloads: z.array(z.object({ id: identifier, packageName: z.string().min(1), version: packageVersion, artifact: lockedArtifactSchema }).strict()),
+  hostProfiles: z.array(z.object({ id: identifier, artifact: lockedArtifactSchema }).strict()).default([]),
   components: z.array(z.object({
     componentId: identifier,
     release: packageVersion,
@@ -276,6 +296,8 @@ const integrationReleaseSchema = z.object({
 }).strict().superRefine((release, context) => {
   const components = release.components.map((component) => component.componentId);
   if (new Set(components).size !== components.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["components"], message: "Integration releases cannot select a component more than once." });
+  const profiles = release.hostProfiles.map((profile) => profile.id);
+  if (new Set(profiles).size !== profiles.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["hostProfiles"], message: "Integration releases cannot select a host profile more than once." });
 });
 const releaseCatalogSchema = z.object({
   schemaVersion: z.literal("treeseed.release-catalog/v1"),
@@ -286,6 +308,7 @@ const releaseCatalogSchema = z.object({
   catalogDigest: digest,
   stableBase: z.object({ release: packageVersion, catalogDigest: digest }).strict().nullable(),
   components: z.array(componentReleaseSchema),
+  hostProfiles: z.array(hostInitializationProfileSchema).default([]),
   createdAt: z.string().datetime()
 }).strict().superRefine((catalog, context) => {
   if (catalog.track === "development" && !catalog.stableBase) context.addIssue({ code: z.ZodIssueCode.custom, path: ["stableBase"], message: "Development catalogs require an exact stable base." });
@@ -293,6 +316,12 @@ const releaseCatalogSchema = z.object({
   if (catalog.track === "development" && catalog.stableBase) for (const [index, component] of catalog.components.entries()) {
     if (component.track !== "development" || component.stableBase?.catalogDigest !== catalog.stableBase.catalogDigest) context.addIssue({ code: z.ZodIssueCode.custom, path: ["components", index, "stableBase", "catalogDigest"], message: "Catalog ingestion must bind every development component to the exact selected stable base." });
   }
+  const profileIds = catalog.hostProfiles.map((profile) => profile.id);
+  if (new Set(profileIds).size !== profileIds.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["hostProfiles"], message: "Release catalogs cannot contain duplicate host profiles." });
+  const components = new Set(catalog.components.map((component) => component.componentId));
+  for (const [profileIndex, profile] of catalog.hostProfiles.entries()) for (const [componentIndex, componentId] of profile.components.entries()) {
+    if (!components.has(componentId)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["hostProfiles", profileIndex, "components", componentIndex], message: `Host profile ${profile.id} selects unavailable component ${componentId}.` });
+  }
 });
 const hostPlanSchema = z.object({ schemaVersion: z.literal("treeseed.host-plan/v1"), planId: identifier, configurationDigest: digest, catalogDigest: digest, changes: z.array(z.object({ componentId: identifier, action: z.enum(["install", "upgrade", "reconfigure", "remove", "noop"]), from: packageVersion.nullable(), to: packageVersion.nullable() }).strict()), blockers: z.array(z.object({ code: identifier, message: z.string().min(1) }).strict()) }).strict();
 const hostBootstrapSchema = z.object({
@@ -368,6 +397,7 @@ export {
   hostConfigurationSchema,
   hostConnectionBindingSchema,
   hostCredentialInitializerSchema,
+  hostInitializationProfileSchema,
   hostMigrationSchema,
   hostPlanSchema,
   hostReceiptSchema,

package/dist/operator-contracts/canonical-command-tree.js

@@ -80,6 +80,7 @@ const operationBindings = {
   "host bootstrap enroll": local("local.host.bootstrap.enroll"),
   "host reset": local("local.host.reset"),
   "host uninstall": local("local.host.uninstall"),
+  "host initialize": local("local.host.initialize"),
   "dev session start": local("local.dev.session.start"),
   "dev session stop": local("local.dev.session.stop"),
   "dev use": local("local.dev.use"),
@@ -217,6 +218,19 @@ function hostUninstall() {
   value.resultSchemaId = "treeseed.host-uninstall-result/v1";
   return value;
 }
+function hostInitialize() {
+  const value = leaf("initialize", "mutation", void 0, "authority");
+  if (value.nodeType !== "leaf") throw new Error("Host initialize must be a leaf command.");
+  value.description = "Initialize the generic host foundation from an immutable catalog-bound profile.";
+  value.options = [
+    ...value.options ?? [],
+    { name: "--profile", description: "Catalog-bound host initialization profile.", type: "string", required: true },
+    { name: "--confirm", description: "Confirm installation of the reviewed profile plan.", type: "boolean" },
+    { name: "--yes", description: "Confirm non-interactive execution after reviewing the plan.", type: "boolean" }
+  ];
+  value.resultSchemaId = "treeseed.host-initialization-result/v1";
+  return value;
+}
 function hostSecurityInitialize() {
   const value = leaf("initialize", "mutation", void 0, "credential");
   if (value.nodeType !== "leaf") throw new Error("Host security initialization must be a leaf command.");
@@ -369,6 +383,7 @@ const commandTree = {
       developmentCommand("verify", "mutation", void 0, [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--candidate", description: "Candidate identity.", type: "string" }])
     ]),
     branch("host", [
+      hostInitialize(),
       leaf("status"),
       leaf("doctor"),
       leaf("plan"),

package/dist/operator-contracts/catalog/communication-operations.d.ts

@@ -14,6 +14,7 @@ export declare function communicationOperations(): {
             projectId: string;
             invocationId: string | null;
             completedAt: string | null;
+            requirement: "required" | "optional";
             agentSlug: string;
             capacity: {
                 status: string | null;
@@ -57,7 +58,6 @@ export declare function communicationOperations(): {
                 agentDefinition: string;
                 chatProfile: string;
             };
-            requirement: "required" | "optional";
             parentInvocationId: string | null;
             depth: number;
             requestedAt: string;
@@ -78,9 +78,9 @@ export declare function communicationOperations(): {
             createdAt: string;
             assignmentId: string | null;
             invocationId: string;
+            requirement: "required" | "optional";
             agentSlug: string;
             projectSlug: string;
-            requirement: "required" | "optional";
             messageRef: string;
             markdown: string;
         }[];
@@ -131,6 +131,7 @@ export declare function communicationOperations(): {
             projectId: string;
             invocationId: string | null;
             completedAt: string | null;
+            requirement: "required" | "optional";
             agentSlug: string;
             capacity: {
                 status: string | null;
@@ -174,7 +175,6 @@ export declare function communicationOperations(): {
                 agentDefinition: string;
                 chatProfile: string;
             };
-            requirement: "required" | "optional";
             parentInvocationId: string | null;
             depth: number;
             requestedAt: string;
@@ -195,9 +195,9 @@ export declare function communicationOperations(): {
             createdAt: string;
             assignmentId: string | null;
             invocationId: string;
+            requirement: "required" | "optional";
             agentSlug: string;
             projectSlug: string;
-            requirement: "required" | "optional";
             messageRef: string;
             markdown: string;
         }[];