@treeseed/sdk 0.13.0-rc.24 → 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

@@ -12,11 +12,34 @@ const operationBindings = {
   "auth login": protocol("protocol.oauth.device.login"),
   "auth logout": protocol("protocol.oauth.revoke"),
   "auth status": operation("accounts.current.show"),
+  "send": operation("communications.send", [field("path", "teamId", "context", "team", true), field("path", "channel", "argument", "channel", true), field("body", "message", "argument", "message", true), field("body", "projectId", "context", "project"), field("body", "recipients", "option", "to"), field("body", "topic", "option"), field("body", "waitSeconds", "option", "wait", false, "integer")]),
   "secrets list": local("local.secrets.list"),
   "secrets status": local("local.secrets.status"),
   "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)]),
@@ -91,8 +114,22 @@ const commandTree = {
   schemaVersion: "treeseed.command-tree/v1",
   executable: "trsd",
   commands: [
+    { 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

@@ -0,0 +1,90 @@
+export declare function communicationOperations(): {
+    send: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        channel: string;
+    }, {}, {
+        message: string;
+        projectId?: string | undefined;
+        recipients?: string[] | undefined;
+        topic?: string | undefined;
+        waitSeconds?: number | undefined;
+    }, {
+        status: "partial" | "failed" | "complete" | "running" | "queued";
+        schemaVersion: "treeseed.communication-send-receipt/v1";
+        createdAt: string;
+        responses: {
+            status: "failed" | "cancelled" | "responded";
+            createdAt: string;
+            projectId: string;
+            agentSlug: string;
+            assignmentId: string | null;
+            invocationId: string;
+            messageRef: string;
+            markdown: string;
+        }[];
+        teamId: string;
+        channel: string;
+        topic: string | null;
+        messageRef: string;
+        sendId: string;
+        discussionId: string;
+        targets: {
+            status: "failed" | "running" | "cancelled" | "queued" | "responded";
+            projectId: string;
+            agentSlug: string;
+            projectSlug: string;
+            definitionRevision: string;
+            invocationId: string | null;
+        }[];
+        updatedAt: string;
+    }>;
+    sendStatus: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        sendId: string;
+    }, {}, undefined, {
+        status: "partial" | "failed" | "complete" | "running" | "queued";
+        schemaVersion: "treeseed.communication-send-receipt/v1";
+        createdAt: string;
+        responses: {
+            status: "failed" | "cancelled" | "responded";
+            createdAt: string;
+            projectId: string;
+            agentSlug: string;
+            assignmentId: string | null;
+            invocationId: string;
+            messageRef: string;
+            markdown: string;
+        }[];
+        teamId: string;
+        channel: string;
+        topic: string | null;
+        messageRef: string;
+        sendId: string;
+        discussionId: string;
+        targets: {
+            status: "failed" | "running" | "cancelled" | "queued" | "responded";
+            projectId: string;
+            agentSlug: string;
+            projectSlug: string;
+            definitionRevision: string;
+            invocationId: string | null;
+        }[];
+        updatedAt: string;
+    }>;
+};
+export declare function providerDiscussionResponseOperation(): import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+    assignmentId: string;
+}, {}, {
+    markdown: string;
+    leaseToken: string;
+    runnerId: string;
+    summary?: string | undefined;
+    usage?: Record<string, unknown> | undefined;
+}, {
+    status: "responded";
+    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
+    assignmentId: string;
+    invocationId: string;
+    messageRef: string;
+    settledAt: string;
+}>;

package/dist/operator-contracts/catalog/communication-operations.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-builder.js";
+import {
+  communicationSendReceiptSchema,
+  communicationSendRequestSchema,
+  providerDiscussionResponseReceiptSchema,
+  providerDiscussionResponseRequestSchema
+} from "../communication/contracts.js";
+const empty = z.object({}).strict();
+const none = z.undefined();
+function communicationOperations() {
+  return {
+    send: defineOperation({ operationId: "communications.send", description: "Post a team-channel message and admit the selected project agents to the communication lane.", rest: { method: "POST", path: "/v1/teams/{teamId}/channels/{channel}/messages" }, parameters: "treeseed.communications.send.parameters/v1", capability: "agents.execute", authentication: "oauth", oauthScopes: ["treeseed:execution"], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "cli", "mcp_tool"], cacheScope: "none", pagination: "none" }, {
+      path: z.object({ teamId: z.string().min(1), channel: z.string().trim().min(1).max(120) }).strict(),
+      query: empty,
+      body: communicationSendRequestSchema,
+      output: communicationSendReceiptSchema
+    }),
+    sendStatus: defineOperation({ operationId: "communications.sends.show", description: "Read a communication send and its durable agent responses.", rest: { method: "GET", path: "/v1/teams/{teamId}/communication-sends/{sendId}" }, parameters: "treeseed.communications.sends.show.parameters/v1", capability: "agents.read", authentication: "oauth", oauthScopes: ["treeseed:read"], kind: "read", riskClass: "ordinary", confirmation: "never", surfaces: ["rest", "mcp_tool", "mcp_resource"], cacheScope: "principal", pagination: "none" }, {
+      path: z.object({ teamId: z.string().min(1), sendId: z.string().min(1) }).strict(),
+      query: empty,
+      body: none,
+      output: communicationSendReceiptSchema
+    })
+  };
+}
+function providerDiscussionResponseOperation() {
+  return defineOperation({ operationId: "providers.assignments.discussion.respond", description: "Commit and settle an assignment-scoped discussion response.", rest: { method: "POST", path: "/v1/provider/assignments/{assignmentId}/discussion-response" }, parameters: "treeseed.providers.assignments.discussion.respond.parameters/v1", capability: "providers.execute", authentication: "provider", oauthScopes: [], kind: "mutation", riskClass: "ordinary", confirmation: "never", surfaces: ["rest"], cacheScope: "none", pagination: "none" }, {
+    path: z.object({ assignmentId: z.string().min(1) }).strict(),
+    query: empty,
+    body: providerDiscussionResponseRequestSchema,
+    output: providerDiscussionResponseReceiptSchema
+  });
+}
+export {
+  communicationOperations,
+  providerDiscussionResponseOperation
+};

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

@@ -0,0 +1,250 @@
+import { z } from 'zod';
+export declare const communicationRecipientSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    agentSlug: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    projectId: string;
+    agentSlug: string;
+}, {
+    projectId: string;
+    agentSlug: string;
+}>;
+export declare const communicationSendRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    topic: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    waitSeconds: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    projectId?: string | undefined;
+    recipients?: string[] | undefined;
+    topic?: string | undefined;
+    waitSeconds?: number | undefined;
+}, {
+    message: string;
+    projectId?: string | undefined;
+    recipients?: string[] | undefined;
+    topic?: string | undefined;
+    waitSeconds?: number | undefined;
+}>;
+export declare const communicationTargetSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    agentSlug: z.ZodString;
+} & {
+    projectSlug: z.ZodString;
+    definitionRevision: z.ZodString;
+    invocationId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<["queued", "running", "responded", "failed", "cancelled"]>;
+}, "strict", z.ZodTypeAny, {
+    status: "failed" | "running" | "cancelled" | "queued" | "responded";
+    projectId: string;
+    agentSlug: string;
+    projectSlug: string;
+    definitionRevision: string;
+    invocationId: string | null;
+}, {
+    status: "failed" | "running" | "cancelled" | "queued" | "responded";
+    projectId: string;
+    agentSlug: string;
+    projectSlug: string;
+    definitionRevision: string;
+    invocationId: string | null;
+}>;
+export declare const communicationResponseSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    agentSlug: z.ZodString;
+} & {
+    invocationId: z.ZodString;
+    assignmentId: z.ZodNullable<z.ZodString>;
+    messageRef: z.ZodString;
+    markdown: z.ZodString;
+    status: z.ZodEnum<["responded", "failed", "cancelled"]>;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "failed" | "cancelled" | "responded";
+    createdAt: string;
+    projectId: string;
+    agentSlug: string;
+    assignmentId: string | null;
+    invocationId: string;
+    messageRef: string;
+    markdown: string;
+}, {
+    status: "failed" | "cancelled" | "responded";
+    createdAt: string;
+    projectId: string;
+    agentSlug: string;
+    assignmentId: string | null;
+    invocationId: string;
+    messageRef: string;
+    markdown: string;
+}>;
+export declare const communicationSendReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.communication-send-receipt/v1">;
+    sendId: z.ZodString;
+    teamId: z.ZodString;
+    channel: z.ZodString;
+    topic: z.ZodNullable<z.ZodString>;
+    discussionId: z.ZodString;
+    messageRef: z.ZodString;
+    status: z.ZodEnum<["queued", "running", "complete", "partial", "failed"]>;
+    targets: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        agentSlug: z.ZodString;
+    } & {
+        projectSlug: z.ZodString;
+        definitionRevision: z.ZodString;
+        invocationId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<["queued", "running", "responded", "failed", "cancelled"]>;
+    }, "strict", z.ZodTypeAny, {
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
+        projectId: string;
+        agentSlug: string;
+        projectSlug: string;
+        definitionRevision: string;
+        invocationId: string | null;
+    }, {
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
+        projectId: string;
+        agentSlug: string;
+        projectSlug: string;
+        definitionRevision: string;
+        invocationId: string | null;
+    }>, "many">;
+    responses: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        agentSlug: z.ZodString;
+    } & {
+        invocationId: z.ZodString;
+        assignmentId: z.ZodNullable<z.ZodString>;
+        messageRef: z.ZodString;
+        markdown: z.ZodString;
+        status: z.ZodEnum<["responded", "failed", "cancelled"]>;
+        createdAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        status: "failed" | "cancelled" | "responded";
+        createdAt: string;
+        projectId: string;
+        agentSlug: string;
+        assignmentId: string | null;
+        invocationId: string;
+        messageRef: string;
+        markdown: string;
+    }, {
+        status: "failed" | "cancelled" | "responded";
+        createdAt: string;
+        projectId: string;
+        agentSlug: string;
+        assignmentId: string | null;
+        invocationId: string;
+        messageRef: string;
+        markdown: 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: "failed" | "cancelled" | "responded";
+        createdAt: string;
+        projectId: string;
+        agentSlug: string;
+        assignmentId: string | null;
+        invocationId: string;
+        messageRef: string;
+        markdown: string;
+    }[];
+    teamId: string;
+    channel: string;
+    topic: string | null;
+    messageRef: string;
+    sendId: string;
+    discussionId: string;
+    targets: {
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
+        projectId: string;
+        agentSlug: string;
+        projectSlug: string;
+        definitionRevision: string;
+        invocationId: string | null;
+    }[];
+    updatedAt: string;
+}, {
+    status: "partial" | "failed" | "complete" | "running" | "queued";
+    schemaVersion: "treeseed.communication-send-receipt/v1";
+    createdAt: string;
+    responses: {
+        status: "failed" | "cancelled" | "responded";
+        createdAt: string;
+        projectId: string;
+        agentSlug: string;
+        assignmentId: string | null;
+        invocationId: string;
+        messageRef: string;
+        markdown: string;
+    }[];
+    teamId: string;
+    channel: string;
+    topic: string | null;
+    messageRef: string;
+    sendId: string;
+    discussionId: string;
+    targets: {
+        status: "failed" | "running" | "cancelled" | "queued" | "responded";
+        projectId: string;
+        agentSlug: string;
+        projectSlug: string;
+        definitionRevision: string;
+        invocationId: string | null;
+    }[];
+    updatedAt: string;
+}>;
+export declare const providerDiscussionResponseRequestSchema: z.ZodObject<{
+    leaseToken: z.ZodString;
+    runnerId: z.ZodString;
+    markdown: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    markdown: string;
+    leaseToken: string;
+    runnerId: string;
+    summary?: string | undefined;
+    usage?: Record<string, unknown> | undefined;
+}, {
+    markdown: string;
+    leaseToken: string;
+    runnerId: string;
+    summary?: string | undefined;
+    usage?: Record<string, unknown> | undefined;
+}>;
+export declare const providerDiscussionResponseReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.provider-discussion-response-receipt/v1">;
+    assignmentId: z.ZodString;
+    invocationId: z.ZodString;
+    messageRef: z.ZodString;
+    status: z.ZodLiteral<"responded">;
+    settledAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "responded";
+    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
+    assignmentId: string;
+    invocationId: string;
+    messageRef: string;
+    settledAt: string;
+}, {
+    status: "responded";
+    schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
+    assignmentId: string;
+    invocationId: string;
+    messageRef: string;
+    settledAt: string;
+}>;
+export type CommunicationSendRequest = z.infer<typeof communicationSendRequestSchema>;
+export type CommunicationSendReceipt = z.infer<typeof communicationSendReceiptSchema>;
+export type CommunicationResponse = z.infer<typeof communicationResponseSchema>;
+export type ProviderDiscussionResponseRequest = z.infer<typeof providerDiscussionResponseRequestSchema>;
+export type ProviderDiscussionResponseReceipt = z.infer<typeof providerDiscussionResponseReceiptSchema>;