@treeseed/sdk 0.13.0-rc.39 → 0.13.0-rc.41

package/dist/development/schemas.js

@@ -0,0 +1,153 @@
+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 relativePath = z.string().min(1).max(512).refine((value) => {
+  if (value.startsWith("/") || value.includes("\\") || value.includes("\0")) return false;
+  return !value.split("/").some((part) => part === ".." || part === "");
+}, "Paths must be safe, normalized, repository-relative paths.");
+const environmentName = z.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/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);
+const developmentModeSchema = z.enum(["released", "candidate", "live"]);
+const developmentTargetKindSchema = z.enum(["package-watch", "live-web", "live-api", "rebuild-restart", "local-companion"]);
+const developmentReactionSchema = z.enum(["reload", "restart", "rebuild", "stale", "manual", "none"]);
+const developmentStatePolicySchema = z.enum(["stateless", "ephemeral", "clone", "shared-compatible"]);
+const operationSchema = z.object({
+  command: z.string().min(1).max(256),
+  args: z.array(z.string().max(4096)).max(64).default([]),
+  cwd: relativePath.optional(),
+  environment: z.record(environmentName, z.string().max(16384)).default({}),
+  timeoutSeconds: z.number().int().positive().max(86400).default(600)
+}).strict();
+const readinessSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("marker"), path: relativePath, timeoutSeconds: z.number().int().positive().max(3600) }).strict(),
+  z.object({ kind: z.literal("http"), path: z.string().startsWith("/"), expectedStatus: z.number().int().min(100).max(599).default(200), timeoutSeconds: z.number().int().positive().max(3600) }).strict(),
+  z.object({ kind: z.literal("tcp"), timeoutSeconds: z.number().int().positive().max(3600) }).strict(),
+  z.object({ kind: z.literal("process"), graceSeconds: z.number().int().nonnegative().max(600).default(2) }).strict()
+]);
+const endpointSchema = z.object({
+  id: identifier,
+  protocol: z.enum(["http", "https", "tcp"]),
+  port: z.number().int().min(1).max(65535),
+  canonicalAlias: localAlias.optional(),
+  visibility: z.enum(["host", "loopback", "private"]),
+  authentication: z.enum(["none", "application", "mtls"]).default("none")
+}).strict().superRefine((endpoint, context) => {
+  if (endpoint.visibility === "host" && !endpoint.canonicalAlias) context.addIssue({ code: z.ZodIssueCode.custom, path: ["canonicalAlias"], message: "Host-visible endpoints require a canonical .localhost alias." });
+  if (endpoint.visibility !== "host" && endpoint.canonicalAlias) context.addIssue({ code: z.ZodIssueCode.custom, path: ["canonicalAlias"], message: "Only host-visible endpoints may request a canonical alias." });
+});
+const outputSchema = z.object({
+  path: relativePath,
+  mediaType: z.string().min(1).max(256),
+  completionMarker: relativePath.optional(),
+  digestAlgorithm: z.literal("sha256").default("sha256")
+}).strict();
+const dependencySchema = z.object({
+  id: identifier,
+  target: identifier,
+  capability: identifier.optional(),
+  locality: z.enum(["local", "remote", "either"]).default("either"),
+  reaction: developmentReactionSchema
+}).strict();
+const freezeSchema = z.object({
+  kind: z.enum(["npm-package", "oci-image", "archive", "executable"]),
+  operation: operationSchema,
+  artifacts: z.array(relativePath).min(1),
+  contractOperations: z.array(operationSchema).default([])
+}).strict();
+const developmentTargetSchema = z.object({
+  id: identifier,
+  kind: developmentTargetKindSchema,
+  platforms: z.array(z.enum(["linux-amd64", "linux-arm64", "darwin-arm64", "darwin-amd64"])).min(1),
+  runtimeRequirements: z.array(z.string().min(1).max(128)).default([]),
+  sourceRoots: z.array(relativePath).min(1),
+  ignoredPaths: z.array(relativePath).default([]),
+  operations: z.object({
+    setup: operationSchema.optional(),
+    watch: operationSchema.optional(),
+    build: operationSchema.optional(),
+    start: operationSchema.optional(),
+    stop: operationSchema.optional(),
+    verify: operationSchema.optional(),
+    cleanup: operationSchema.optional()
+  }).strict(),
+  ready: readinessSchema,
+  outputs: z.array(outputSchema).default([]),
+  endpoints: z.array(endpointSchema).default([]),
+  dependencies: z.array(dependencySchema).default([]),
+  statePolicy: developmentStatePolicySchema,
+  migrationPolicy: z.enum(["none", "explicit-review", "disposable-only"]),
+  secretRefs: z.record(environmentName, identifier).default({}),
+  shutdown: z.object({ drainOperation: operationSchema.optional(), graceSeconds: z.number().int().nonnegative().max(3600).default(30), activeWorkPolicy: z.enum(["block", "drain", "cancel-authorized"]).default("block") }).strict(),
+  resources: z.object({ cpuCores: z.number().positive().optional(), memoryBytes: z.number().int().positive().optional(), diskBytes: z.number().int().positive().optional() }).strict().default({}),
+  logs: z.array(relativePath).default([]),
+  forbiddenOperations: z.array(z.string().min(1).max(128)).default([]),
+  freeze: freezeSchema.optional(),
+  promotion: z.object({ liveAdmissible: z.literal(false), candidateRequiresVerification: z.literal(true) }).strict()
+}).strict().superRefine((target, context) => {
+  const endpoints = target.endpoints.map((entry) => entry.id);
+  if (new Set(endpoints).size !== endpoints.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["endpoints"], message: "Development endpoint IDs must be unique." });
+  if (target.kind === "package-watch" && target.endpoints.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["endpoints"], message: "Package-watch targets cannot own service endpoints." });
+  if (target.kind === "local-companion" && target.endpoints.some((entry) => entry.visibility !== "loopback")) context.addIssue({ code: z.ZodIssueCode.custom, path: ["endpoints"], message: "Local companions must remain loopback-only." });
+  if (target.kind !== "package-watch" && target.ready.kind === "marker") context.addIssue({ code: z.ZodIssueCode.custom, path: ["ready"], message: "Service targets require process, TCP, or HTTP readiness." });
+  if (target.statePolicy === "shared-compatible" && target.migrationPolicy !== "explicit-review") context.addIssue({ code: z.ZodIssueCode.custom, path: ["migrationPolicy"], message: "Shared state requires explicit migration review." });
+});
+const developmentRuntimeSchema = z.object({
+  schemaVersion: z.literal("treeseed.development-runtime/v1"),
+  project: z.object({ id: identifier, repository: z.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/iu) }).strict(),
+  defaults: z.object({ leaseSeconds: z.number().int().min(60).max(86400).default(14400), restoreOnFailure: z.boolean().default(true) }).strict(),
+  targets: z.array(developmentTargetSchema).min(1)
+}).strict().superRefine((runtime, context) => {
+  const ids = runtime.targets.map((target) => target.id);
+  if (new Set(ids).size !== ids.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["targets"], message: "Development target IDs must be unique." });
+});
+const repositoryClosureSchema = z.object({
+  projectId: identifier,
+  repository: z.string().min(1),
+  worktree: z.string().min(1),
+  commit: gitCommit,
+  branch: z.string().min(1).nullable(),
+  dirty: z.boolean(),
+  dirtyDigest: digest.nullable(),
+  recipeDigest: digest
+}).strict();
+const developmentSessionSchema = z.object({
+  schemaVersion: z.literal("treeseed.development-session/v1"),
+  sessionId: identifier,
+  actor: z.string().min(1).max(256),
+  hostId: identifier,
+  createdAt: z.string().datetime(),
+  expiresAt: z.string().datetime(),
+  status: z.enum(["planning", "active", "degraded", "restoring", "stopped", "expired"]),
+  repositories: z.array(repositoryClosureSchema),
+  targets: z.array(z.object({ projectId: identifier, targetId: identifier, mode: developmentModeSchema, generation: z.number().int().nonnegative(), health: z.enum(["pending", "ready", "degraded", "stopped"]), reaction: developmentReactionSchema.optional() }).strict()),
+  leases: z.array(z.object({ kind: z.enum(["alias", "component", "state", "secret"]), resource: z.string().min(1), acquiredAt: z.string().datetime(), expiresAt: z.string().datetime() }).strict()),
+  restoredReceiptId: identifier.nullable(),
+  blockers: z.array(z.object({ code: identifier, message: z.string().min(1), targetId: identifier.optional() }).strict())
+}).strict();
+const developmentCandidateSchema = z.object({
+  schemaVersion: z.literal("treeseed.development-candidate/v1"),
+  candidateId: identifier,
+  sessionId: identifier,
+  createdAt: z.string().datetime(),
+  source: z.array(repositoryClosureSchema),
+  artifacts: z.array(z.object({ projectId: identifier, targetId: identifier, kind: z.enum(["npm-package", "oci-image", "archive", "executable", "contract-bundle"]), identity: z.string().min(1), digest, integrity: z.string().min(1).optional() }).strict()).min(1),
+  configurationDigest: digest,
+  dependencyGenerations: z.record(z.number().int().nonnegative()),
+  compatibilityAttestations: z.array(z.object({ contractId: z.string().min(1), digest, compatible: z.boolean(), minimumBump: z.enum(["none", "patch", "minor", "major"]) }).strict()),
+  verification: z.object({ status: z.enum(["pending", "passed", "failed"]), operations: z.array(z.string().min(1)), completedAt: z.string().datetime().nullable() }).strict(),
+  promotable: z.boolean()
+}).strict().superRefine((candidate, context) => {
+  if (candidate.source.some((source) => source.dirty) && candidate.promotable) context.addIssue({ code: z.ZodIssueCode.custom, path: ["promotable"], message: "Candidates containing dirty source cannot be promotable." });
+  if (candidate.verification.status !== "passed" && candidate.promotable) context.addIssue({ code: z.ZodIssueCode.custom, path: ["promotable"], message: "Only verified candidates can be promotable." });
+});
+export {
+  developmentCandidateSchema,
+  developmentModeSchema,
+  developmentReactionSchema,
+  developmentRuntimeSchema,
+  developmentSessionSchema,
+  developmentStatePolicySchema,
+  developmentTargetKindSchema,
+  developmentTargetSchema
+};

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

@@ -53,6 +53,15 @@ const operationBindings = {
   "host bootstrap status": local("local.host.bootstrap.status"),
   "host bootstrap enroll": local("local.host.bootstrap.enroll"),
   "host reset": local("local.host.reset"),
+  "dev session start": local("local.dev.session.start"),
+  "dev session stop": local("local.dev.session.stop"),
+  "dev use": local("local.dev.use"),
+  "dev rebuild": local("local.dev.rebuild"),
+  "dev status": local("local.dev.status"),
+  "dev logs": local("local.dev.logs"),
+  "dev plan": local("local.dev.plan"),
+  "dev freeze": local("local.dev.freeze"),
+  "dev verify": local("local.dev.verify"),
   "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)]),
@@ -191,6 +200,19 @@ function addOptions(node, options) {
   if (node.nodeType === "leaf") node.options = [...node.options ?? [], ...options];
   return node;
 }
+function developmentCommand(segment, kind, argument, options = []) {
+  return {
+    nodeType: "leaf",
+    segment,
+    description: `${segment[0].toUpperCase()}${segment.slice(1)} a local development session.`,
+    kind,
+    arguments: argument ? [{ name: argument, description: `${argument} value.`, required: true }] : void 0,
+    options: [...kind === "mutation" ? [planOption] : [], ...options],
+    authorization: kind === "mutation" ? { capability: `development.${segment}`, confirmation: "never" } : void 0,
+    resultSchemaId: `treeseed.command.dev.${segment}/v1`,
+    execution: local(`local.dev.${segment}`)
+  };
+}
 const commandTree = {
   schemaVersion: "treeseed.command-tree/v1",
   executable: "trsd",
@@ -200,6 +222,19 @@ const commandTree = {
     branch("users", [userCreate()]),
     branch("teams", [leaf("list"), { nodeType: "leaf", segment: "current", description: "Show the active team for this authenticated server session.", kind: "read", resultSchemaId: "treeseed.command.teams.current/v1", execution: unavailable() }, { nodeType: "leaf", segment: "use", description: "Select the active team for this authenticated server session.", kind: "mutation", arguments: [{ name: "team", description: "Team UUID or unambiguous slug.", required: true }], options: [planOption], authorization: { capability: "teams.read", confirmation: "never" }, resultSchemaId: "treeseed.command.teams.use/v1", execution: unavailable() }]),
     branch("secrets", [leaf("list"), leaf("status"), leaf("unlock", "mutation", void 0, "credential"), leaf("lock", "mutation"), leaf("rotate", "mutation", void 0, "credential")]),
+    branch("dev", [
+      branch("session", [
+        developmentCommand("start", "mutation", "manifest", [{ name: "--actor", description: "Audited development-session actor.", type: "string" }, { name: "--lease-seconds", description: "Requested bounded lease duration.", type: "number" }]),
+        developmentCommand("stop", "mutation", void 0, [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--restore", description: "Restore released routes and targets.", type: "boolean" }])
+      ]),
+      developmentCommand("use", "mutation", "selection", [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--target", description: "Additional project.target=mode selections.", type: "string[]" }]),
+      developmentCommand("rebuild", "mutation", "target", [{ name: "--session", description: "Development session identity.", type: "string" }]),
+      developmentCommand("status", "read", void 0, [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--all", description: "Include stopped and expired sessions.", type: "boolean" }]),
+      developmentCommand("logs", "read", void 0, [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--target", description: "Development target identity.", type: "string" }, { name: "--follow", description: "Follow target logs.", type: "boolean" }]),
+      developmentCommand("plan", "read", void 0, [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--affected", description: "Show the smallest affected closure.", type: "boolean" }]),
+      developmentCommand("freeze", "mutation", void 0, [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--allow-dirty", description: "Create a non-promotable dirty-source candidate.", type: "boolean" }]),
+      developmentCommand("verify", "mutation", void 0, [{ name: "--session", description: "Development session identity.", type: "string" }, { name: "--candidate", description: "Candidate identity.", type: "string" }])
+    ]),
     branch("host", [
       leaf("status"),
       leaf("doctor"),

package/dist/operator-contracts/catalog/admin-account-team-operations.d.ts

@@ -0,0 +1,33 @@
+export declare const adminAccountOperations: {
+    readonly updateUsername: import("../control-plane-operation.js").ControlPlaneOperationBinding<{}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly notificationPreferences: import("../control-plane-operation.js").ControlPlaneOperationBinding<{}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly updateNotificationPreferences: import("../control-plane-operation.js").ControlPlaneOperationBinding<{}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly themes: import("../control-plane-operation.js").ControlPlaneOperationBinding<{}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly createTheme: import("../control-plane-operation.js").ControlPlaneOperationBinding<{}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly updateTheme: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        themeId: string;
+    }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly deleteTheme: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        themeId: string;
+    }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly unlinkProvider: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        identityId: string;
+    }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+};
+export declare const adminTeamOperations: {
+    readonly revokeInvite: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        inviteId: string;
+    }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly resendInvite: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        inviteId: string;
+    }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly memberRemovalBlockers: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        membershipId: string;
+    }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly remove: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+    }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+};

package/dist/operator-contracts/catalog/admin-account-team-operations.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-builder.js";
+const empty = z.object({}).strict();
+const none = z.undefined();
+const record = z.record(z.unknown());
+function operation(operationId, method, path, pathShape, options) {
+  const read = method === "GET";
+  const riskClass = options.risk ?? "ordinary";
+  return defineOperation({
+    operationId,
+    description: `${read ? "Read" : "Apply"} ${operationId}.`,
+    rest: { method, path },
+    ...Object.keys(pathShape).length ? { parameters: `treeseed.${operationId}.parameters/v1` } : {},
+    capability: options.capability,
+    authentication: "oauth",
+    oauthScopes: [read ? "treeseed:read" : "treeseed:projects:write"],
+    kind: read ? "read" : "mutation",
+    riskClass,
+    confirmation: riskClass === "ordinary" ? "never" : "input_required",
+    surfaces: ["rest"],
+    cacheScope: read ? "principal" : "none",
+    pagination: options.pagination ?? "none",
+    concurrencyRequired: options.concurrency,
+    redactedPaths: options.redactedPaths
+  }, {
+    path: z.object(pathShape).strict(),
+    query: read ? record : empty,
+    body: read ? none : record,
+    output: record
+  });
+}
+const adminAccountOperations = {
+  updateUsername: operation("accounts.username.update", "PATCH", "/v1/auth/web/username", {}, { capability: "accounts.write", concurrency: true }),
+  notificationPreferences: operation("accounts.notification.preferences.show", "GET", "/v1/auth/web/notifications/preferences", {}, { capability: "accounts.read" }),
+  updateNotificationPreferences: operation("accounts.notification.preferences.update", "PUT", "/v1/auth/web/notifications/preferences", {}, { capability: "accounts.write", concurrency: true }),
+  themes: operation("accounts.themes.list", "GET", "/v1/auth/web/themes", {}, { capability: "accounts.read", pagination: "cursor" }),
+  createTheme: operation("accounts.themes.create", "POST", "/v1/auth/web/themes", {}, { capability: "accounts.write" }),
+  updateTheme: operation("accounts.themes.update", "PUT", "/v1/auth/web/themes/{themeId}", { themeId: z.string().min(1) }, { capability: "accounts.write", concurrency: true }),
+  deleteTheme: operation("accounts.themes.delete", "DELETE", "/v1/auth/web/themes/{themeId}", { themeId: z.string().min(1) }, { capability: "accounts.write", risk: "destructive", concurrency: true }),
+  unlinkProvider: operation("accounts.providers.unlink", "DELETE", "/v1/auth/web/providers/{identityId}", { identityId: z.string().min(1) }, { capability: "accounts.write", risk: "credential" })
+};
+const adminTeamOperations = {
+  revokeInvite: operation("teams.invites.revoke", "DELETE", "/v1/teams/{teamId}/invites/{inviteId}", { teamId: z.string().min(1), inviteId: z.string().min(1) }, { capability: "teams.write", risk: "destructive", concurrency: true }),
+  resendInvite: operation("teams.invites.resend", "POST", "/v1/teams/{teamId}/invites/{inviteId}/resend", { teamId: z.string().min(1), inviteId: z.string().min(1) }, { capability: "teams.write" }),
+  memberRemovalBlockers: operation("teams.members.removal.blockers", "GET", "/v1/teams/{teamId}/members/{membershipId}/removal-blockers", { teamId: z.string().min(1), membershipId: z.string().min(1) }, { capability: "teams.read" }),
+  remove: operation("teams.delete", "DELETE", "/v1/teams/{teamId}/permanent-delete", { teamId: z.string().min(1) }, { capability: "teams.delete", risk: "irreversible", concurrency: true, redactedPaths: ["body.confirmation", "body.currentPassword", "body.reauthenticationGrantId"] })
+};
+export {
+  adminAccountOperations,
+  adminTeamOperations
+};

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

@@ -8,40 +8,12 @@ export declare function communicationOperations(): {
         timeoutSeconds?: number | undefined;
         recipients?: string[] | undefined;
     }, {
-        status: "partial" | "failed" | "complete" | "running" | "queued";
+        status: "failed" | "partial" | "complete" | "running" | "queued";
         schemaVersion: "treeseed.communication-send-receipt/v2";
-        createdAt: string;
-        responses: {
-            status: "failed" | "cancelled" | "responded" | "abstained";
-            createdAt: string;
-            projectId: string;
-            agentSlug: string;
-            assignmentId: string | null;
-            invocationId: string;
-            requirement: "required" | "optional";
-            messageRef: string;
-            markdown: string;
-        }[];
-        teamId: string;
-        channel: string;
-        updatedAt: string;
-        messageRef: string;
-        sendId: string;
-        topic: {
-            id: string;
-            slug: string;
-        };
-        projectStream: {
-            id: string;
-            projectId: string;
-            projectSlug: string;
-        };
-        discussionId: string;
-        sourceMessage: string;
         targets: {
             status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-            completedAt: string | null;
             projectId: string;
+            completedAt: string | null;
             agentSlug: string;
             capacity: {
                 status: string | null;
@@ -75,19 +47,11 @@ export declare function communicationOperations(): {
                 message: string | null;
             } | null;
         }[];
-        replayed: boolean;
-    }>;
-    sendStatus: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
-        teamId: string;
-        sendId: string;
-    }, {}, undefined, {
-        status: "partial" | "failed" | "complete" | "running" | "queued";
-        schemaVersion: "treeseed.communication-send-receipt/v2";
         createdAt: string;
         responses: {
             status: "failed" | "cancelled" | "responded" | "abstained";
-            createdAt: string;
             projectId: string;
+            createdAt: string;
             agentSlug: string;
             assignmentId: string | null;
             invocationId: string;
@@ -111,10 +75,18 @@ export declare function communicationOperations(): {
         };
         discussionId: string;
         sourceMessage: string;
+        replayed: boolean;
+    }>;
+    sendStatus: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+        teamId: string;
+        sendId: string;
+    }, {}, undefined, {
+        status: "failed" | "partial" | "complete" | "running" | "queued";
+        schemaVersion: "treeseed.communication-send-receipt/v2";
         targets: {
             status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-            completedAt: string | null;
             projectId: string;
+            completedAt: string | null;
             agentSlug: string;
             capacity: {
                 status: string | null;
@@ -148,6 +120,34 @@ export declare function communicationOperations(): {
                 message: string | null;
             } | null;
         }[];
+        createdAt: string;
+        responses: {
+            status: "failed" | "cancelled" | "responded" | "abstained";
+            projectId: string;
+            createdAt: string;
+            agentSlug: string;
+            assignmentId: string | null;
+            invocationId: string;
+            requirement: "required" | "optional";
+            messageRef: string;
+            markdown: string;
+        }[];
+        teamId: string;
+        channel: string;
+        updatedAt: string;
+        messageRef: string;
+        sendId: string;
+        topic: {
+            id: string;
+            slug: string;
+        };
+        projectStream: {
+            id: string;
+            projectId: string;
+            projectSlug: string;
+        };
+        discussionId: string;
+        sourceMessage: string;
         replayed: boolean;
     }>;
 };

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

@@ -104,8 +104,8 @@ export declare const communicationTargetSchema: z.ZodObject<{
     }>;
 }, "strict", z.ZodTypeAny, {
     status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-    completedAt: string | null;
     projectId: string;
+    completedAt: string | null;
     agentSlug: string;
     capacity: {
         status: string | null;
@@ -140,8 +140,8 @@ export declare const communicationTargetSchema: z.ZodObject<{
     } | null;
 }, {
     status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-    completedAt: string | null;
     projectId: string;
+    completedAt: string | null;
     agentSlug: string;
     capacity: {
         status: string | null;
@@ -188,8 +188,8 @@ export declare const communicationResponseSchema: z.ZodObject<{
     createdAt: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     status: "failed" | "cancelled" | "responded" | "abstained";
-    createdAt: string;
     projectId: string;
+    createdAt: string;
     agentSlug: string;
     assignmentId: string | null;
     invocationId: string;
@@ -198,8 +198,8 @@ export declare const communicationResponseSchema: z.ZodObject<{
     markdown: string;
 }, {
     status: "failed" | "cancelled" | "responded" | "abstained";
-    createdAt: string;
     projectId: string;
+    createdAt: string;
     agentSlug: string;
     assignmentId: string | null;
     invocationId: string;
@@ -318,8 +318,8 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
         }>;
     }, "strict", z.ZodTypeAny, {
         status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-        completedAt: string | null;
         projectId: string;
+        completedAt: string | null;
         agentSlug: string;
         capacity: {
             status: string | null;
@@ -354,8 +354,8 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
         } | null;
     }, {
         status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-        completedAt: string | null;
         projectId: string;
+        completedAt: string | null;
         agentSlug: string;
         capacity: {
             status: string | null;
@@ -402,8 +402,8 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
         createdAt: z.ZodString;
     }, "strict", z.ZodTypeAny, {
         status: "failed" | "cancelled" | "responded" | "abstained";
-        createdAt: string;
         projectId: string;
+        createdAt: string;
         agentSlug: string;
         assignmentId: string | null;
         invocationId: string;
@@ -412,8 +412,8 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
         markdown: string;
     }, {
         status: "failed" | "cancelled" | "responded" | "abstained";
-        createdAt: string;
         projectId: string;
+        createdAt: string;
         agentSlug: string;
         assignmentId: string | null;
         invocationId: string;
@@ -425,40 +425,12 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
     updatedAt: z.ZodString;
     replayed: z.ZodBoolean;
 }, "strict", z.ZodTypeAny, {
-    status: "partial" | "failed" | "complete" | "running" | "queued";
+    status: "failed" | "partial" | "complete" | "running" | "queued";
     schemaVersion: "treeseed.communication-send-receipt/v2";
-    createdAt: string;
-    responses: {
-        status: "failed" | "cancelled" | "responded" | "abstained";
-        createdAt: string;
-        projectId: string;
-        agentSlug: string;
-        assignmentId: string | null;
-        invocationId: string;
-        requirement: "required" | "optional";
-        messageRef: string;
-        markdown: string;
-    }[];
-    teamId: string;
-    channel: string;
-    updatedAt: string;
-    messageRef: string;
-    sendId: string;
-    topic: {
-        id: string;
-        slug: string;
-    };
-    projectStream: {
-        id: string;
-        projectId: string;
-        projectSlug: string;
-    };
-    discussionId: string;
-    sourceMessage: string;
     targets: {
         status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-        completedAt: string | null;
         projectId: string;
+        completedAt: string | null;
         agentSlug: string;
         capacity: {
             status: string | null;
@@ -492,15 +464,11 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
             message: string | null;
         } | null;
     }[];
-    replayed: boolean;
-}, {
-    status: "partial" | "failed" | "complete" | "running" | "queued";
-    schemaVersion: "treeseed.communication-send-receipt/v2";
     createdAt: string;
     responses: {
         status: "failed" | "cancelled" | "responded" | "abstained";
-        createdAt: string;
         projectId: string;
+        createdAt: string;
         agentSlug: string;
         assignmentId: string | null;
         invocationId: string;
@@ -524,10 +492,14 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
     };
     discussionId: string;
     sourceMessage: string;
+    replayed: boolean;
+}, {
+    status: "failed" | "partial" | "complete" | "running" | "queued";
+    schemaVersion: "treeseed.communication-send-receipt/v2";
     targets: {
         status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
-        completedAt: string | null;
         projectId: string;
+        completedAt: string | null;
         agentSlug: string;
         capacity: {
             status: string | null;
@@ -561,6 +533,34 @@ export declare const communicationSendReceiptSchema: z.ZodObject<{
             message: string | null;
         } | null;
     }[];
+    createdAt: string;
+    responses: {
+        status: "failed" | "cancelled" | "responded" | "abstained";
+        projectId: string;
+        createdAt: string;
+        agentSlug: string;
+        assignmentId: string | null;
+        invocationId: string;
+        requirement: "required" | "optional";
+        messageRef: string;
+        markdown: string;
+    }[];
+    teamId: string;
+    channel: string;
+    updatedAt: string;
+    messageRef: string;
+    sendId: string;
+    topic: {
+        id: string;
+        slug: string;
+    };
+    projectStream: {
+        id: string;
+        projectId: string;
+        projectSlug: string;
+    };
+    discussionId: string;
+    sourceMessage: string;
     replayed: boolean;
 }>;
 export declare const providerDiscussionResponseRequestSchema: z.ZodEffects<z.ZodObject<{