@treeseed/sdk 0.13.0-rc.25 → 0.13.0-rc.26

package/dist/deployment/schemas.js

@@ -0,0 +1,179 @@
+import { z } from "zod";
+const identifier = z.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const gitCommit = z.string().regex(/^[a-f0-9]{40}$/u);
+const packageVersion = z.string().min(1).regex(/^[0-9][0-9A-Za-z.+:~-]*$/u);
+const localAlias = z.string().regex(
+  /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*\.localhost$/u,
+  "Host aliases must use the .localhost namespace."
+);
+const binding = z.string().regex(/^(?:\[[0-9a-f:]+\]|[^:]+):[1-9][0-9]{0,4}$/iu);
+const deploymentTrackSchema = z.enum(["stable", "development"]);
+const hostComponentSchema = z.object({
+  enabled: z.boolean(),
+  track: deploymentTrackSchema,
+  profile: identifier.optional(),
+  aliases: z.record(z.string().min(1), localAlias).default({}),
+  configuration: z.record(z.unknown()).default({})
+}).strict();
+const hostConfigurationSchema = z.object({
+  schemaVersion: z.literal("treeseed.host/v1"),
+  configurationId: identifier,
+  generation: z.number().int().positive(),
+  host: z.object({
+    id: identifier,
+    role: identifier,
+    architecture: z.literal("amd64")
+  }).strict(),
+  runtime: z.object({ management: z.enum(["managed", "external"]) }).strict(),
+  updates: z.object({
+    defaultTrack: deploymentTrackSchema,
+    stable: z.object({
+      metadataPollSeconds: z.number().int().min(3600),
+      maintenanceWindow: z.object({
+        weekday: z.enum(["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]),
+        localTime: z.string().regex(/^(?:[01][0-9]|2[0-3]):[0-5][0-9]$/u),
+        jitterMinutes: z.number().int().min(0).max(30)
+      }).strict()
+    }).strict(),
+    development: z.object({ pollSeconds: z.literal(60) }).strict()
+  }).strict(),
+  components: z.record(identifier, hostComponentSchema),
+  network: z.object({
+    manager: z.object({ binding, aliases: z.array(localAlias).min(1), sans: z.array(z.string().min(1)), trustedLanCidrs: z.array(z.string().min(1)) }).strict()
+  }).strict(),
+  secrets: z.record(identifier, z.object({
+    provider: z.enum(["file", "systemd-credential", "vault", "aws-secrets-manager"]),
+    reference: z.string().min(1)
+  }).strict())
+}).strict();
+const packageEndpointSchema = z.object({
+  id: identifier,
+  protocol: z.enum(["http", "https", "tcp"]),
+  port: z.number().int().min(1).max(65535),
+  visibility: z.enum(["private", "host"]),
+  defaultAlias: localAlias.optional(),
+  aliasOverride: z.boolean().default(true),
+  tls: z.enum(["edge", "passthrough", "none"]),
+  authentication: z.enum(["none", "application", "mtls"]),
+  healthGate: z.object({ protocol: z.enum(["http", "https", "tcp"]), path: z.string().startsWith("/").optional(), timeoutSeconds: z.number().int().positive().max(600) }).strict().optional()
+}).strict().superRefine((endpoint, context) => {
+  if (endpoint.visibility === "host" && !endpoint.defaultAlias) context.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultAlias"], message: "Host-visible endpoints require a .localhost alias." });
+  if (endpoint.visibility === "host" && !endpoint.healthGate) context.addIssue({ code: z.ZodIssueCode.custom, path: ["healthGate"], message: "Host-visible endpoints require a health gate." });
+  if (endpoint.visibility === "private" && endpoint.defaultAlias) context.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultAlias"], message: "Private endpoints cannot declare host aliases." });
+});
+const packageRuntimeSchema = z.object({
+  schemaVersion: z.literal("treeseed.package-runtime/v1"),
+  componentId: identifier,
+  version: packageVersion,
+  compose: z.object({ projectName: identifier, files: z.array(z.string().min(1)).min(1) }).strict(),
+  services: z.array(z.object({ id: identifier, composeService: identifier, endpoints: z.array(packageEndpointSchema) }).strict()).min(1),
+  stateVolumes: z.array(z.object({ id: identifier, volume: z.string().min(1), backup: z.enum(["required", "optional", "none"]) }).strict()),
+  migrations: z.array(z.object({ id: identifier, order: z.number().int().nonnegative(), backupRequired: z.boolean() }).strict()),
+  requiredCapabilities: z.array(identifier)
+}).strict().superRefine((runtime, context) => {
+  const endpointIds = runtime.services.flatMap((service) => service.endpoints.map((endpoint) => `${service.id}.${endpoint.id}`));
+  if (new Set(endpointIds).size !== endpointIds.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["services"], message: "Endpoint identities must be unique within a component." });
+});
+const catalogPackageSchema = z.object({ name: z.string().regex(/^treeseed(?:-[a-z0-9-]+)?$/u), version: packageVersion, architecture: z.enum(["amd64", "all"]), origin: z.literal("TreeSeed Deployment"), order: z.number().int().nonnegative() }).strict();
+const catalogImageSchema = z.object({ role: identifier, repository: z.string().regex(/^treeseed\/[a-z0-9-]+$/u), digest, platforms: z.array(z.enum(["linux/amd64", "linux/arm64"])).min(1), consumers: z.array(identifier).min(1) }).strict();
+const componentReleaseSchema = z.object({
+  schemaVersion: z.literal("treeseed.component-release/v1"),
+  componentId: identifier,
+  release: packageVersion,
+  track: deploymentTrackSchema,
+  source: z.object({ repository: z.string().regex(/^treeseed-ai\/[a-z0-9-]+$/u), commit: gitCommit }).strict(),
+  stableBase: z.object({ releaseRange: z.string().min(1), compatibilityId: identifier, catalogDigest: digest }).strict().nullable(),
+  packages: z.array(catalogPackageSchema).min(1),
+  images: z.array(catalogImageSchema),
+  runtime: packageRuntimeSchema,
+  runtimeDigest: digest,
+  rollback: z.object({ compatible: z.boolean(), requiresBackup: z.boolean() }).strict(),
+  evidence: z.object({ provenance: z.array(z.string().url()), sboms: z.array(z.string().url()), vulnerabilities: z.array(z.string().url()) }).strict()
+}).strict().superRefine((release, context) => {
+  if (release.runtime.componentId !== release.componentId || release.runtime.version !== release.release) context.addIssue({ code: z.ZodIssueCode.custom, path: ["runtime"], message: "Runtime identity must match its component release." });
+  if (release.track === "development" && !release.stableBase) context.addIssue({ code: z.ZodIssueCode.custom, path: ["stableBase"], message: "Development releases require an exact stable-base binding." });
+  if (release.track === "stable" && release.stableBase) context.addIssue({ code: z.ZodIssueCode.custom, path: ["stableBase"], message: "Stable releases cannot be overlays." });
+});
+const releaseCatalogSchema = z.object({
+  schemaVersion: z.literal("treeseed.release-catalog/v1"),
+  release: packageVersion,
+  generation: z.number().int().positive(),
+  track: deploymentTrackSchema,
+  compatibilityId: identifier,
+  catalogDigest: digest,
+  stableBase: z.object({ release: packageVersion, catalogDigest: digest }).strict().nullable(),
+  components: z.array(componentReleaseSchema).min(1),
+  createdAt: z.string().datetime()
+}).strict();
+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({
+  schemaVersion: z.literal("treeseed.host-bootstrap/v1"),
+  bootstrapId: identifier,
+  configurationDigest: digest,
+  apt: z.object({ origin: z.literal("TreeSeed Deployment"), suite: deploymentTrackSchema, repository: z.string().url(), keyFingerprint: z.string().regex(/^[A-F0-9]{40}$/u) }).strict(),
+  packages: z.array(catalogPackageSchema).min(1),
+  credentialPolicy: z.object({ noStoreResponse: z.literal(true), redactedLogging: z.literal(true), ephemeralGeneration: z.literal(true), deleteAfterInstall: z.literal(true) }).strict(),
+  createdAt: z.string().datetime()
+}).strict();
+const hostUpdateSchema = z.object({
+  schemaVersion: z.literal("treeseed.host-update/v1"),
+  updateId: identifier,
+  track: deploymentTrackSchema,
+  fromCatalogDigest: digest,
+  toCatalogDigest: digest,
+  components: z.array(z.object({ componentId: identifier, from: packageVersion.nullable(), to: packageVersion, imageDigests: z.array(digest) }).strict()).min(1),
+  activation: z.object({ policy: z.enum(["maintenance-window", "continuous"]), eligibleAt: z.string().datetime(), jitterSeconds: z.number().int().nonnegative() }).strict(),
+  state: z.enum(["planned", "draining", "applying", "healthy", "failed", "rolled-back"])
+}).strict();
+const hostReceiptSchema = z.object({ schemaVersion: z.literal("treeseed.host-receipt/v1"), receiptId: identifier, planId: identifier, state: z.enum(["known-good", "degraded", "rolled-back"]), configurationDigest: digest, catalogDigest: digest, packages: z.array(catalogPackageSchema), images: z.array(catalogImageSchema), completedAt: z.string().datetime() }).strict();
+const hostBackupSchema = z.object({
+  schemaVersion: z.literal("treeseed.host-backup/v1"),
+  backupId: identifier,
+  componentId: identifier,
+  generation: z.number().int().positive(),
+  state: z.enum(["pending", "complete", "failed", "verified"]),
+  artifacts: z.array(z.object({ volumeId: identifier, location: z.string().min(1), digest, encrypted: z.boolean() }).strict()),
+  createdAt: z.string().datetime(),
+  verifiedAt: z.string().datetime().nullable()
+}).strict();
+const hostMigrationSchema = z.object({
+  schemaVersion: z.literal("treeseed.host-migration/v1"),
+  migrationId: identifier,
+  componentId: identifier,
+  operation: identifier,
+  fromGeneration: z.number().int().nonnegative(),
+  toGeneration: z.number().int().positive(),
+  backupId: identifier.nullable(),
+  state: z.enum(["pending", "quiesced", "copied", "verified", "activated", "failed", "rolled-back"]),
+  sourceWritersStopped: z.boolean(),
+  completedAt: z.string().datetime().nullable()
+}).strict();
+const hostRecoverySchema = z.object({
+  schemaVersion: z.literal("treeseed.host-recovery/v1"),
+  recoveryId: identifier,
+  receiptId: identifier,
+  componentId: identifier.nullable(),
+  trigger: z.enum(["health-gate", "operator", "boot", "interrupted-update"]),
+  action: z.enum(["retry", "rollback", "restore"]),
+  targetGeneration: z.number().int().positive(),
+  state: z.enum(["pending", "running", "healthy", "failed"]),
+  backupId: identifier.nullable(),
+  completedAt: z.string().datetime().nullable()
+}).strict();
+export {
+  componentReleaseSchema,
+  deploymentTrackSchema,
+  hostBackupSchema,
+  hostBootstrapSchema,
+  hostComponentSchema,
+  hostConfigurationSchema,
+  hostMigrationSchema,
+  hostPlanSchema,
+  hostReceiptSchema,
+  hostRecoverySchema,
+  hostUpdateSchema,
+  packageEndpointSchema,
+  packageRuntimeSchema,
+  releaseCatalogSchema
+};

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

@@ -18,6 +18,28 @@ const operationBindings = {
   "secrets unlock": local("local.secrets.unlock"),
   "secrets lock": local("local.secrets.lock"),
   "secrets rotate": local("local.secrets.rotate"),
+  "host status": local("local.host.status"),
+  "host doctor": local("local.host.doctor"),
+  "host plan": local("local.host.plan"),
+  "host apply": local("local.host.apply"),
+  "host reconcile": local("local.host.reconcile"),
+  "host events": local("local.host.events"),
+  "host update status": local("local.host.update.status"),
+  "host update check": local("local.host.update.check"),
+  "host update apply": local("local.host.update.apply"),
+  "host update channel": local("local.host.update.channel"),
+  "host update pause": local("local.host.update.pause"),
+  "host update resume": local("local.host.update.resume"),
+  "host component list": local("local.host.component.list"),
+  "host component status": local("local.host.component.status"),
+  "host component enable": local("local.host.component.enable"),
+  "host component disable": local("local.host.component.disable"),
+  "host aliases list": local("local.host.aliases.list"),
+  "host recovery status": local("local.host.recovery.status"),
+  "host recovery retry": local("local.host.recovery.retry"),
+  "host recovery restore": local("local.host.recovery.restore"),
+  "host bootstrap status": local("local.host.bootstrap.status"),
+  "host bootstrap enroll": local("local.host.bootstrap.enroll"),
   "agents list": operation("agents.list", [field("path", "projectId", "context", "project", true), ...page()]),
   "agents show": operation("agents.show", [field("path", "projectId", "context", "project", true), field("path", "agentSlug", "argument", "agent", true)]),
   "agents classes list": operation("agents.classes.list", [field("path", "projectId", "context", "project", true)]),
@@ -95,6 +117,19 @@ const commandTree = {
     { nodeType: "leaf", segment: "send", description: "Send a message to project agents through a team discussion channel.", kind: "mutation", arguments: [{ name: "channel", description: "Team discussion channel.", required: true }, { name: "message", description: "Markdown message to send.", required: true }], options: [planOption, { name: "--team", description: "Team identity or slug.", type: "string" }, { name: "--project", description: "Default project for unqualified agent names.", type: "string" }, { name: "--to", description: "Agent target; use project/agent when names may be ambiguous.", type: "string[]" }, { name: "--topic", description: "Optional discussion topic.", type: "string" }, { name: "--wait", description: "Seconds to wait for durable responses.", type: "number", defaultValue: 0 }], authorization: { capability: "agents.execute", confirmation: "never" }, resultSchemaId: "treeseed.communication-send-receipt/v1", execution: unavailable() },
     branch("auth", [leaf("login", "mutation", void 0, "credential"), leaf("logout", "mutation"), leaf("status")]),
     branch("secrets", [leaf("list"), leaf("status"), leaf("unlock", "mutation", void 0, "credential"), leaf("lock", "mutation"), leaf("rotate", "mutation", void 0, "credential")]),
+    branch("host", [
+      leaf("status"),
+      leaf("doctor"),
+      leaf("plan"),
+      leaf("apply", "mutation", void 0, "authority"),
+      leaf("reconcile", "mutation", void 0, "authority"),
+      leaf("events"),
+      branch("update", [leaf("status"), leaf("check", "mutation"), leaf("apply", "mutation", void 0, "authority"), leaf("channel", "mutation", "track", "authority"), leaf("pause", "mutation", void 0, "authority"), leaf("resume", "mutation", void 0, "authority")]),
+      branch("component", [leaf("list"), leaf("status", "read", "component"), leaf("enable", "mutation", "component", "authority"), leaf("disable", "mutation", "component", "destructive")]),
+      branch("aliases", [leaf("list")]),
+      branch("recovery", [leaf("status"), leaf("retry", "mutation", void 0, "authority"), leaf("restore", "mutation", "generation", "destructive")]),
+      branch("bootstrap", [leaf("status"), leaf("enroll", "mutation", void 0, "credential")])
+    ]),
     branch("agents", [
       leaf("list"),
       leaf("show", "read", "agent"),

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

@@ -9,27 +9,27 @@ export declare function communicationOperations(): {
         topic?: string | undefined;
         waitSeconds?: number | undefined;
     }, {
+        status: "partial" | "failed" | "complete" | "running" | "queued";
         schemaVersion: "treeseed.communication-send-receipt/v1";
+        createdAt: string;
         responses: {
-            status: "cancelled" | "failed" | "responded";
+            status: "failed" | "cancelled" | "responded";
+            createdAt: string;
             projectId: string;
             agentSlug: string;
             assignmentId: string | null;
             invocationId: string;
             messageRef: string;
             markdown: string;
-            createdAt: string;
         }[];
-        status: "failed" | "queued" | "running" | "complete" | "partial";
         teamId: string;
         channel: string;
         topic: string | null;
         messageRef: string;
-        createdAt: string;
         sendId: string;
         discussionId: string;
         targets: {
-            status: "cancelled" | "failed" | "queued" | "running" | "responded";
+            status: "failed" | "running" | "cancelled" | "queued" | "responded";
             projectId: string;
             agentSlug: string;
             projectSlug: string;
@@ -42,27 +42,27 @@ export declare function communicationOperations(): {
         teamId: string;
         sendId: string;
     }, {}, undefined, {
+        status: "partial" | "failed" | "complete" | "running" | "queued";
         schemaVersion: "treeseed.communication-send-receipt/v1";
+        createdAt: string;
         responses: {
-            status: "cancelled" | "failed" | "responded";
+            status: "failed" | "cancelled" | "responded";
+            createdAt: string;
             projectId: string;
             agentSlug: string;
             assignmentId: string | null;
             invocationId: string;
             messageRef: string;
             markdown: string;
-            createdAt: string;
         }[];
-        status: "failed" | "queued" | "running" | "complete" | "partial";
         teamId: string;
         channel: string;
         topic: string | null;
         messageRef: string;
-        createdAt: string;
         sendId: string;
         discussionId: string;
         targets: {
-            status: "cancelled" | "failed" | "queued" | "running" | "responded";
+            status: "failed" | "running" | "cancelled" | "queued" | "responded";
             projectId: string;
             agentSlug: string;
             projectSlug: string;
@@ -81,8 +81,8 @@ export declare function providerDiscussionResponseOperation(): import("../contro
     summary?: string | undefined;
     usage?: Record<string, unknown> | undefined;
 }, {
-    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
     status: "responded";
+    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
     assignmentId: string;
     invocationId: string;
     messageRef: string;

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

@@ -37,14 +37,14 @@ export declare const communicationTargetSchema: z.ZodObject<{
     invocationId: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<["queued", "running", "responded", "failed", "cancelled"]>;
 }, "strict", z.ZodTypeAny, {
-    status: "cancelled" | "failed" | "queued" | "running" | "responded";
+    status: "failed" | "running" | "cancelled" | "queued" | "responded";
     projectId: string;
     agentSlug: string;
     projectSlug: string;
     definitionRevision: string;
     invocationId: string | null;
 }, {
-    status: "cancelled" | "failed" | "queued" | "running" | "responded";
+    status: "failed" | "running" | "cancelled" | "queued" | "responded";
     projectId: string;
     agentSlug: string;
     projectSlug: string;
@@ -62,23 +62,23 @@ export declare const communicationResponseSchema: z.ZodObject<{
     status: z.ZodEnum<["responded", "failed", "cancelled"]>;
     createdAt: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    status: "cancelled" | "failed" | "responded";
+    status: "failed" | "cancelled" | "responded";
+    createdAt: string;
     projectId: string;
     agentSlug: string;
     assignmentId: string | null;
     invocationId: string;
     messageRef: string;
     markdown: string;
-    createdAt: string;
 }, {
-    status: "cancelled" | "failed" | "responded";
+    status: "failed" | "cancelled" | "responded";
+    createdAt: string;
     projectId: string;
     agentSlug: string;
     assignmentId: string | null;
     invocationId: string;
     messageRef: string;
     markdown: string;
-    createdAt: string;
 }>;
 export declare const communicationSendReceiptSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"treeseed.communication-send-receipt/v1">;
@@ -98,14 +98,14 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
         invocationId: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<["queued", "running", "responded", "failed", "cancelled"]>;
     }, "strict", z.ZodTypeAny, {
-        status: "cancelled" | "failed" | "queued" | "running" | "responded";
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
         projectId: string;
         agentSlug: string;
         projectSlug: string;
         definitionRevision: string;
         invocationId: string | null;
     }, {
-        status: "cancelled" | "failed" | "queued" | "running" | "responded";
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
         projectId: string;
         agentSlug: string;
         projectSlug: string;
@@ -123,48 +123,48 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
         status: z.ZodEnum<["responded", "failed", "cancelled"]>;
         createdAt: z.ZodString;
     }, "strict", z.ZodTypeAny, {
-        status: "cancelled" | "failed" | "responded";
+        status: "failed" | "cancelled" | "responded";
+        createdAt: string;
         projectId: string;
         agentSlug: string;
         assignmentId: string | null;
         invocationId: string;
         messageRef: string;
         markdown: string;
-        createdAt: string;
     }, {
-        status: "cancelled" | "failed" | "responded";
+        status: "failed" | "cancelled" | "responded";
+        createdAt: string;
         projectId: string;
         agentSlug: string;
         assignmentId: string | null;
         invocationId: string;
         messageRef: string;
         markdown: string;
-        createdAt: string;
     }>, "many">;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, "strict", z.ZodTypeAny, {
+    status: "partial" | "failed" | "complete" | "running" | "queued";
     schemaVersion: "treeseed.communication-send-receipt/v1";
+    createdAt: string;
     responses: {
-        status: "cancelled" | "failed" | "responded";
+        status: "failed" | "cancelled" | "responded";
+        createdAt: string;
         projectId: string;
         agentSlug: string;
         assignmentId: string | null;
         invocationId: string;
         messageRef: string;
         markdown: string;
-        createdAt: string;
     }[];
-    status: "failed" | "queued" | "running" | "complete" | "partial";
     teamId: string;
     channel: string;
     topic: string | null;
     messageRef: string;
-    createdAt: string;
     sendId: string;
     discussionId: string;
     targets: {
-        status: "cancelled" | "failed" | "queued" | "running" | "responded";
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
         projectId: string;
         agentSlug: string;
         projectSlug: string;
@@ -173,27 +173,27 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
     }[];
     updatedAt: string;
 }, {
+    status: "partial" | "failed" | "complete" | "running" | "queued";
     schemaVersion: "treeseed.communication-send-receipt/v1";
+    createdAt: string;
     responses: {
-        status: "cancelled" | "failed" | "responded";
+        status: "failed" | "cancelled" | "responded";
+        createdAt: string;
         projectId: string;
         agentSlug: string;
         assignmentId: string | null;
         invocationId: string;
         messageRef: string;
         markdown: string;
-        createdAt: string;
     }[];
-    status: "failed" | "queued" | "running" | "complete" | "partial";
     teamId: string;
     channel: string;
     topic: string | null;
     messageRef: string;
-    createdAt: string;
     sendId: string;
     discussionId: string;
     targets: {
-        status: "cancelled" | "failed" | "queued" | "running" | "responded";
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
         projectId: string;
         agentSlug: string;
         projectSlug: string;
@@ -229,15 +229,15 @@ export declare const providerDiscussionResponseReceiptSchema: z.ZodObject<{
     status: z.ZodLiteral<"responded">;
     settledAt: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
     status: "responded";
+    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
     assignmentId: string;
     invocationId: string;
     messageRef: string;
     settledAt: string;
 }, {
-    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
     status: "responded";
+    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
     assignmentId: string;
     invocationId: string;
     messageRef: string;

package/dist/operator-contracts/control-plane-operations.d.ts

@@ -471,27 +471,27 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             topic?: string | undefined;
             waitSeconds?: number | undefined;
         }, {
+            status: "partial" | "failed" | "complete" | "running" | "queued";
             schemaVersion: "treeseed.communication-send-receipt/v1";
+            createdAt: string;
             responses: {
-                status: "cancelled" | "failed" | "responded";
+                status: "failed" | "cancelled" | "responded";
+                createdAt: string;
                 projectId: string;
                 agentSlug: string;
                 assignmentId: string | null;
                 invocationId: string;
                 messageRef: string;
                 markdown: string;
-                createdAt: string;
             }[];
-            status: "failed" | "queued" | "running" | "complete" | "partial";
             teamId: string;
             channel: string;
             topic: string | null;
             messageRef: string;
-            createdAt: string;
             sendId: string;
             discussionId: string;
             targets: {
-                status: "cancelled" | "failed" | "queued" | "running" | "responded";
+                status: "failed" | "running" | "cancelled" | "queued" | "responded";
                 projectId: string;
                 agentSlug: string;
                 projectSlug: string;
@@ -504,27 +504,27 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             teamId: string;
             sendId: string;
         }, {}, undefined, {
+            status: "partial" | "failed" | "complete" | "running" | "queued";
             schemaVersion: "treeseed.communication-send-receipt/v1";
+            createdAt: string;
             responses: {
-                status: "cancelled" | "failed" | "responded";
+                status: "failed" | "cancelled" | "responded";
+                createdAt: string;
                 projectId: string;
                 agentSlug: string;
                 assignmentId: string | null;
                 invocationId: string;
                 messageRef: string;
                 markdown: string;
-                createdAt: string;
             }[];
-            status: "failed" | "queued" | "running" | "complete" | "partial";
             teamId: string;
             channel: string;
             topic: string | null;
             messageRef: string;
-            createdAt: string;
             sendId: string;
             discussionId: string;
             targets: {
-                status: "cancelled" | "failed" | "queued" | "running" | "responded";
+                status: "failed" | "running" | "cancelled" | "queued" | "responded";
                 projectId: string;
                 agentSlug: string;
                 projectSlug: string;
@@ -1074,8 +1074,8 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             summary?: string | undefined;
             usage?: Record<string, unknown> | undefined;
         }, {
-            schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
             status: "responded";
+            schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
             assignmentId: string;
             invocationId: string;
             messageRef: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.25",
+  "version": "0.13.0-rc.26",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {
@@ -61,6 +61,10 @@
     "vitest": "^4.1.2"
   },
   "exports": {
+    "./deployment": {
+      "types": "./dist/deployment/index.d.ts",
+      "default": "./dist/deployment/index.js"
+    },
     "./standards": {
       "types": "./dist/standards/index.d.ts",
       "default": "./dist/standards/index.js"