@treeseed/sdk 0.13.0-rc.81 → 0.13.0-rc.83

package/dist/.treeseed-build-complete.json

@@ -1 +1 @@
-{"completedAt":"2026-09-03T01:31:02.124Z"}
+{"completedAt":"2026-09-03T07:04:23.401Z"}

package/dist/agent-capacity/artifact-mutation-receipt.d.ts

@@ -1,7 +1,7 @@
 export declare const ARTIFACT_MUTATION_RECEIPT_SCHEMA: "treeseed.artifact-mutation-receipt/v1";
 export type ArtifactMutationKind = 'treedx-content' | 'source-checkpoint';
 export type ArtifactMutationPhase = 'provisional' | 'integrated';
-import type { AgentWorkExecutionMode, UpstreamMutationPolicy } from './contracts/support/execution-mode.js';
+import type { AgentWorkExecutionMode, UpstreamMutationPolicy } from './contracts/support/authority/execution-mode.js';
 export interface ArtifactMutationEvidence {
     ref: string;
     digest?: string | null;

package/dist/agent-capacity/contracts/capacity/assignments/assignment-records.d.ts

@@ -1,5 +1,5 @@
 export type AgentExecutionMode = 'planning' | 'acting';
-export type AgentWorkExecutionMode = import('../../support/execution-mode.js').AgentWorkExecutionMode;
+import type { AgentWorkExecutionMode } from '../../support/authority/execution-mode.js';
 export type ProviderAssignmentStatus = 'pending' | 'leased' | 'running' | 'completed' | 'failed' | 'returned' | 'expired' | 'cancelled';
 export type ProviderAssignmentLeaseState = 'unleased' | 'leased' | 'released' | 'expired';
 export type AgentModeRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';

package/dist/agent-capacity/contracts/capacity/workdays/workday-records.d.ts

@@ -1,6 +1,6 @@
 /** Portable durable records shared by workday control-plane and operator consumers. */
 import type { WorkdayAgentSelection } from '../../../workday.js';
-import type { AgentWorkExecutionMode } from '../../support/execution-mode.js';
+import type { AgentWorkExecutionMode } from '../../support/authority/execution-mode.js';
 export type CapacityWorkdayRunStatus = 'queued' | 'running' | 'completed' | 'cancelled' | 'failed' | 'degraded';
 export type CapacityWorkdayEventStatus = 'recorded' | 'active' | 'completed' | 'warning' | 'error' | 'failed';
 export type CapacityWorkdayDemandSource = 'objective' | 'question' | 'proposal' | 'decision-review' | 'knowledge-gap' | 'release-readiness' | 'idle-intent' | 'planning-input' | 'capacity-plan' | 'assignment-completion' | 'assignment-blockage' | 'workday-summary' | 'handoff' | 'research-workflow';

package/dist/agent-capacity/contracts/runtime/runtime-observability.d.ts

@@ -1,9 +1,9 @@
 import type { CapacityPageInfo } from '../../../capacity/capacity-core/capacity-pagination.js';
 import type { ExecutionCapabilityDemand, ExecutionCapabilitySupply } from '../../../types/agents.js';
-import type { AgentCapacityEnvelope, AgentExecutionMode, AgentModeRun, DecisionExecutionInput, ProviderAssignment, ProviderAssignmentSynthesisSource, TreeDxProxyHandle, WorkdayCapacityEnvelope } from '../capacity/assignments/assignment-records.js';
-import type { AgentKernelPolicy, AgentKernelProfile } from '../projects/agents/project-agent-class.js';
+import type { AgentCapacityEnvelope, AgentExecutionMode, AgentModeRun, AgentModeRunUsageSettlement, DecisionExecutionInput, ProviderAssignment, ProviderAssignmentSynthesisSource, TreeDxProxyHandle, WorkdayCapacityEnvelope } from '../capacity/assignments/assignment-records.js';
+import type { AgentKernelPolicy, AgentKernelProfile, ProjectAgentClass } from '../projects/agents/project-agent-class.js';
 import type { CapacityLedgerEntry, CapacityReservation, CapacityUsageActual } from '../support/financial-records.js';
-import type { WorkdayCapacityEnvelopeRecord } from '../support/planning-records.js';
+import type { DecisionPlanningStatus, WorkdayCapacityEnvelopeRecord } from '../support/planning-records.js';
 export type AgentKernelModeExecutionStatus = 'completed' | 'waiting' | 'failed' | 'returned';
 export type AgentKernelModeFallbackCode = 'assignment_missing_project_or_agent' | 'assignment_governance_provenance_missing' | 'assignment_lease_expired' | 'assignment_mode_not_allowed' | 'assignment_missing_capacity_envelope' | 'assignment_missing_decision_input' | 'assignment_handler_failed' | 'assignment_project_not_synced' | 'assignment_agent_not_found' | 'assignment_insufficient_capability' | 'assignment_decision_not_ready' | 'assignment_capacity_plan_not_accepted' | 'assignment_capacity_not_reserved' | 'assignment_capability_handle_invalid' | 'assignment_capability_handle_secret_material' | 'assignment_capability_handle_write_not_ready' | 'assignment_capability_handle_workspace_denied' | 'assignment_repository_ref_scope_invalid' | 'assignment_workflow_operation_denied' | 'assignment_eligibility_capability_mismatch' | 'assignment_retry_policy_exceeded' | 'assignment_treedx_proxy_scope_invalid' | 'assignment_fallback_quota_exceeded' | 'assignment_output_invalid';
 export interface AgentCapacityPlan {

package/dist/agent-capacity/contracts/support/decision-work.d.ts

@@ -189,7 +189,7 @@ export interface DecisionAssignmentGraph {
     edges: DecisionAssignmentGraphEdge[];
     compiledAt?: string | null;
     compiledBy: 'api-control-plane';
-    executionMode?: import('./execution-mode.js').AgentWorkExecutionMode;
+    executionMode?: import('./authority/execution-mode.js').AgentWorkExecutionMode;
     metadata?: Record<string, unknown>;
 }
 export interface DecisionAssignmentGraphRecord extends DecisionAssignmentGraph {

package/dist/configuration/secrets-capability.d.ts

@@ -2,3 +2,4 @@ export * from '../secrets-capability/service-provider-contracts.js';
 export * from '../secrets-capability/provider-operation-contracts.js';
 export * from '../secrets-capability/workflow-operation-contracts.js';
 export * from '../secrets-capability/service-vault-contracts.js';
+export * from '../secrets-capability/service-vault-crypto.js';

package/dist/configuration/secrets-capability.js

@@ -2,3 +2,4 @@ export * from "../secrets-capability/service-provider-contracts.js";
 export * from "../secrets-capability/provider-operation-contracts.js";
 export * from "../secrets-capability/workflow-operation-contracts.js";
 export * from "../secrets-capability/service-vault-contracts.js";
+export * from "../secrets-capability/service-vault-crypto.js";

package/dist/operator-contracts/catalog/services/service-vault-operations.d.ts

@@ -0,0 +1,17 @@
+export declare const SERVICE_VAULT_OPERATIONS: {
+    readonly userVaultKey: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly putUserVaultKey: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly teamVault: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly initializeTeamVault: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly resetTeamVault: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly rotateTeamVault: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly vaultGrantCandidates: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly createVaultGrant: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly deleteVaultGrant: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly vaultCredentialEnvelopes: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly credentialEnvelopes: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly putCredentialEnvelope: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly createOperationLease: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly operationLease: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    readonly putOperationLeasePayload: import("../../control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+};

package/dist/operator-contracts/catalog/services/service-vault-operations.js

@@ -0,0 +1,114 @@
+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());
+const teamPath = z.object({ teamId: z.string().min(1) }).strict();
+function vaultOperation(operationId, method, path, pathSchema, options = {}) {
+  const read = method === "GET", risk = options.risk ?? "ordinary";
+  return defineOperation({
+    operationId,
+    description: `${read ? "Read" : "Apply"} ${operationId}.`,
+    rest: { method, path },
+    capability: read ? "secrets.read" : "secrets.write",
+    ...path.includes("{") ? { parameters: `treeseed.${operationId}.parameters/v1` } : {},
+    authentication: "oauth",
+    oauthScopes: read ? ["treeseed:read"] : ["treeseed:projects:write"],
+    kind: read ? "read" : "mutation",
+    riskClass: risk,
+    confirmation: risk === "ordinary" ? "never" : "input_required",
+    surfaces: ["rest"],
+    cacheScope: read ? "principal" : "none",
+    pagination: "none",
+    redactedPaths: options.redactedPaths
+  }, { path: pathSchema, query: read ? record : empty, body: read ? none : record, output: record });
+}
+const SERVICE_VAULT_OPERATIONS = {
+  userVaultKey: vaultOperation("services.vault.user.key.show", "GET", "/v1/users/me/vault-key", empty),
+  putUserVaultKey: vaultOperation(
+    "services.vault.user.key.put",
+    "PUT",
+    "/v1/users/me/vault-key",
+    empty,
+    { risk: "credential", redactedPaths: ["body.encryptedPrivateKeyEnvelope"] }
+  ),
+  teamVault: vaultOperation("services.vault.team.show", "GET", "/v1/teams/{teamId}/vault", teamPath),
+  initializeTeamVault: vaultOperation(
+    "services.vault.team.initialize",
+    "POST",
+    "/v1/teams/{teamId}/vault",
+    teamPath,
+    { risk: "credential", redactedPaths: ["body.wrappedTeamVaultKey"] }
+  ),
+  resetTeamVault: vaultOperation(
+    "services.vault.team.reset",
+    "POST",
+    "/v1/teams/{teamId}/vault/reset",
+    teamPath,
+    { risk: "destructive", redactedPaths: ["body.wrappedTeamVaultKey", "body.currentPassword"] }
+  ),
+  rotateTeamVault: vaultOperation(
+    "services.vault.team.rotate",
+    "POST",
+    "/v1/teams/{teamId}/vault/rotate",
+    teamPath,
+    { risk: "credential", redactedPaths: ["body.envelopes", "body.grants"] }
+  ),
+  vaultGrantCandidates: vaultOperation("services.vault.grant.candidates.list", "GET", "/v1/teams/{teamId}/vault/grant-candidates", teamPath),
+  createVaultGrant: vaultOperation(
+    "services.vault.grants.create",
+    "POST",
+    "/v1/teams/{teamId}/vault/grants",
+    teamPath,
+    { risk: "credential", redactedPaths: ["body.wrappedTeamVaultKey"] }
+  ),
+  deleteVaultGrant: vaultOperation(
+    "services.vault.grants.delete",
+    "DELETE",
+    "/v1/teams/{teamId}/vault/grants/{grantId}",
+    z.object({ teamId: z.string().min(1), grantId: z.string().min(1) }).strict(),
+    { risk: "destructive" }
+  ),
+  vaultCredentialEnvelopes: vaultOperation(
+    "services.vault.credential.envelopes.list",
+    "GET",
+    "/v1/teams/{teamId}/vault/credential-envelopes",
+    teamPath
+  ),
+  credentialEnvelopes: vaultOperation(
+    "services.credential.envelopes.list",
+    "GET",
+    "/v1/teams/{teamId}/services/{connectionId}/credential-envelopes",
+    z.object({ teamId: z.string().min(1), connectionId: z.string().min(1) }).strict()
+  ),
+  putCredentialEnvelope: vaultOperation(
+    "services.credential.envelopes.put",
+    "POST",
+    "/v1/teams/{teamId}/services/{connectionId}/credential-envelopes",
+    z.object({ teamId: z.string().min(1), connectionId: z.string().min(1) }).strict(),
+    { risk: "credential", redactedPaths: ["body.envelope"] }
+  ),
+  createOperationLease: vaultOperation(
+    "services.operation.leases.create",
+    "POST",
+    "/v1/teams/{teamId}/service-operation-leases",
+    teamPath,
+    { risk: "authority" }
+  ),
+  operationLease: vaultOperation(
+    "services.operation.leases.show",
+    "GET",
+    "/v1/teams/{teamId}/service-operation-leases/{leaseId}",
+    z.object({ teamId: z.string().min(1), leaseId: z.string().min(1) }).strict()
+  ),
+  putOperationLeasePayload: vaultOperation(
+    "services.operation.leases.payload.put",
+    "PUT",
+    "/v1/teams/{teamId}/service-operation-leases/{leaseId}/payload",
+    z.object({ teamId: z.string().min(1), leaseId: z.string().min(1) }).strict(),
+    { risk: "credential", redactedPaths: ["body.sealedPayload"] }
+  )
+};
+export {
+  SERVICE_VAULT_OPERATIONS
+};

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

@@ -1323,6 +1323,21 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             profileId: string;
             connectionId: string;
         }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly userVaultKey: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly putUserVaultKey: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly teamVault: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly initializeTeamVault: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly resetTeamVault: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly rotateTeamVault: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly vaultGrantCandidates: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly createVaultGrant: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly deleteVaultGrant: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly vaultCredentialEnvelopes: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly credentialEnvelopes: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly putCredentialEnvelope: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly createOperationLease: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly operationLease: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly putOperationLeasePayload: import("./control-plane-operation.js").ControlPlaneOperationBinding<any, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
     };
     readonly agents: {
         readonly list: import("./control-plane-operation.js").ControlPlaneOperationBinding<{

package/dist/operator-contracts/control-plane-operations.js

@@ -8,6 +8,7 @@ import { capabilityOntologyOperations } from "./catalog/capability-ontology-oper
 import { knowledgeShareOperations } from "./catalog/knowledge-share-operations.js";
 import { PROVIDER_ENVIRONMENT_OPERATIONS } from "./catalog/provider-environment-operations.js";
 import { HOSTED_TOPOLOGY_OPERATIONS } from "./catalog/hosted-topology-operations.js";
+import { SERVICE_VAULT_OPERATIONS } from "./catalog/services/service-vault-operations.js";
 import { buildControlPlaneCatalog, flattenControlPlaneOperations } from "./catalog/control-plane-catalog.js";
 const empty = z.object({}).strict(), none = z.undefined(), record = z.record(z.unknown()), payload = record;
 function read(operationId, path, capability, surfaces = ["rest"]) {
@@ -277,6 +278,7 @@ const CONTROL_PLANE_OPERATIONS = {
     deleteWorkflowVariable: resource("repositories.workflow.variables.delete", "DELETE", "/v1/projects/{projectId}/workflow-configuration/variables/{name}", { projectId: z.string().min(1), name: z.string().min(1) }, { capability: "workflows.write", risk: "destructive", concurrency: true })
   },
   services: {
+    ...SERVICE_VAULT_OPERATIONS,
     providers: resource("services.providers.list", "GET", "/v1/service-providers", {}, { capability: "services.read", surfaces: ["rest", "cli", "mcp_tool"] }),
     connections: resource("services.connections.list", "GET", "/v1/teams/{teamId}/services", { teamId: z.string().min(1) }, { capability: "services.read", surfaces: ["rest", "cli", "mcp_tool"], pagination: "cursor" }),
     connection: resource("services.connections.show", "GET", "/v1/teams/{teamId}/services/{connectionId}", { teamId: z.string().min(1), connectionId: z.string().min(1) }, { capability: "services.read", surfaces: ["rest", "cli", "mcp_resource"] }),
@@ -335,12 +337,12 @@ const CONTROL_PLANE_OPERATIONS = {
     retry: resource("assignments.retry", "POST", "/v1/teams/{teamId}/capacity/assignments/{assignmentId}/requeue", { teamId: z.string().min(1), assignmentId: z.string().min(1) }, { capability: "assignments.execute", scopes: ["treeseed:execution"], surfaces: ["rest", "cli", "mcp_tool"], risk: "authority" })
   },
   operations: {
-    list: resource("operations.list", "GET", "/v1/platform/operations", {}, { capability: "operations.read", surfaces: ["rest", "mcp_tool"], pagination: "cursor" }),
+    list: resource("operations.list", "GET", "/v1/platform/operations", {}, { capability: "operations.read", surfaces: ["rest", "cli", "mcp_tool"], pagination: "cursor" }),
     create: resource("operations.create", "POST", "/v1/platform/operations", {}, { capability: "operations.execute", scopes: ["treeseed:execution"] }),
-    show: resource("operations.show", "GET", "/v1/platform/operations/{operationId}", { operationId: z.string().min(1) }, { capability: "operations.read", surfaces: ["rest", "mcp_resource"] }),
+    show: resource("operations.show", "GET", "/v1/platform/operations/{operationId}", { operationId: z.string().min(1) }, { capability: "operations.read", surfaces: ["rest", "cli", "mcp_resource"] }),
     events: resource("operations.events.list", "GET", "/v1/platform/operations/{operationId}/events", { operationId: z.string().min(1) }, { capability: "operations.read", pagination: "cursor" }),
     cancel: resource("operations.cancel", "POST", "/v1/platform/operations/{operationId}/cancel", { operationId: z.string().min(1) }, { capability: "operations.execute", scopes: ["treeseed:execution"], risk: "destructive" }),
-    retry: resource("operations.retry", "POST", "/v1/platform/operations/{operationId}/retry", { operationId: z.string().min(1) }, { capability: "operations.execute", scopes: ["treeseed:execution"] })
+    retry: resource("operations.retry", "POST", "/v1/platform/operations/{operationId}/retry", { operationId: z.string().min(1) }, { capability: "operations.execute", scopes: ["treeseed:execution"], surfaces: ["rest", "cli"] })
   },
   seeds: {
     runs: resource("seeds.runs.list", "GET", "/v1/seeds/runs", {}, { capability: "seeds.read", pagination: "cursor" }),

package/dist/secrets-capability/service-provider-contracts.js

@@ -61,10 +61,10 @@ const SERVICE_PROVIDER_CATALOG = [
       {
         id: "github-repository-app",
         label: "Repository Connector App",
-        description: "Installation authority narrowed to one repository for guarded Git reads and writes.",
+        description: "Installation authority for governed repository creation and guarded Git reads and writes.",
         capabilities: ["repository-hosting"],
         fields: [],
-        permissions: ["Metadata: read", "Contents: read and write"],
+        permissions: ["Metadata: read", "Contents: read and write", "Checks: read", "Administration: read and write"],
         sharing: "capability-scoped",
         unattendedCompatible: true,
         authoritySchemes: ["app-installation"],
@@ -130,9 +130,9 @@ const SERVICE_PROVIDER_CATALOG = [
       { type: "object-storage", label: "Object storage", description: "R2-backed immutable publication and private artifact storage.", credentialProfileIds: ["cloudflare-storage"], status: "available" }
     ],
     credentialProfiles: [
-      { id: "cloudflare-runtime", label: "Pages and Workers token", description: "A token limited to application deployment resources.", capabilities: ["frontend-hosting"], fields: [field("apiToken", "API token", "Encrypted in this browser and used only for authorized frontend operations.", true, true)], permissions: ["Account: Workers Scripts Edit", "Account: Pages Edit"], sharing: "capability-scoped", unattendedCompatible: true, authoritySchemes: ["environment-reference", "external-vault", "workload-identity"], knowledgePageIds: ["provider.cloudflare", "services.credentials", "vault.rotation"] },
-      { id: "cloudflare-dns", label: "DNS token", description: "A token restricted to selected zones.", capabilities: ["dns-management"], fields: [field("apiToken", "DNS API token", "Encrypted separately from deployment authority.", true, true)], permissions: ["Zone: DNS Edit for only the managed zones"], sharing: "capability-scoped", unattendedCompatible: true, authoritySchemes: ["environment-reference", "external-vault", "workload-identity"], knowledgePageIds: ["provider.cloudflare", "services.credentials", "vault.rotation"] },
-      { id: "cloudflare-storage", label: "Storage authority", description: "Vault-custodied R2 management and S3-compatible state credentials, isolated from runtime and DNS authority.", capabilities: ["object-storage"], fields: [field("apiToken", "Storage API token", "Encrypted separately and used only to reconcile authorized R2 resources.", true, true), field("accessKeyId", "R2 access key ID", "Vault-custodied S3-compatible access key identifier for encrypted OpenTofu state.", true, true), field("secretAccessKey", "R2 secret access key", "Vault-custodied S3-compatible secret key for encrypted OpenTofu state.", true, true)], permissions: ["Account: Workers R2 Storage Edit", "Object read and write for only the managed state bucket"], sharing: "capability-scoped", unattendedCompatible: true, authoritySchemes: ["environment-reference", "external-vault", "workload-identity"], knowledgePageIds: ["provider.cloudflare", "services.credentials", "vault.rotation"] }
+      { id: "cloudflare-runtime", label: "Pages and Workers token", description: "A token limited to application deployment resources.", capabilities: ["frontend-hosting"], fields: [field("apiToken", "API token", "Encrypted in this browser and used only for authorized frontend operations.", true, true)], permissions: ["Account: Workers Scripts Edit", "Account: Pages Edit"], sharing: "capability-scoped", unattendedCompatible: true, authoritySchemes: ["environment-reference", "client-encrypted", "external-vault", "workload-identity"], knowledgePageIds: ["provider.cloudflare", "services.credentials", "vault.rotation"] },
+      { id: "cloudflare-dns", label: "DNS token", description: "A token restricted to selected zones.", capabilities: ["dns-management"], fields: [field("apiToken", "DNS API token", "Encrypted separately from deployment authority.", true, true)], permissions: ["Zone: DNS Edit for only the managed zones"], sharing: "capability-scoped", unattendedCompatible: true, authoritySchemes: ["environment-reference", "client-encrypted", "external-vault", "workload-identity"], knowledgePageIds: ["provider.cloudflare", "services.credentials", "vault.rotation"] },
+      { id: "cloudflare-storage", label: "Storage authority", description: "Vault-custodied R2 management and S3-compatible state credentials, isolated from runtime and DNS authority.", capabilities: ["object-storage"], fields: [field("apiToken", "Storage API token", "Encrypted separately and used only to reconcile authorized R2 resources.", true, true), field("accessKeyId", "R2 access key ID", "Vault-custodied S3-compatible access key identifier for encrypted OpenTofu state.", true, true), field("secretAccessKey", "R2 secret access key", "Vault-custodied S3-compatible secret key for encrypted OpenTofu state.", true, true), field("stateEncryptionKey", "OpenTofu state encryption key", "Generated in the browser and encrypted separately; never store this key with the R2 state object.", true, true)], permissions: ["Account: Workers R2 Storage Edit", "Object read and write for only the managed state bucket"], sharing: "capability-scoped", unattendedCompatible: true, authoritySchemes: ["environment-reference", "client-encrypted", "external-vault", "workload-identity"], knowledgePageIds: ["provider.cloudflare", "services.credentials", "vault.rotation"] }
     ]
   },
   {
@@ -163,7 +163,7 @@ const SERVICE_PROVIDER_CATALOG = [
       permissions: ["Workspace access required by the selected operations"],
       sharing: "provider-shared",
       unattendedCompatible: true,
-      authoritySchemes: ["environment-reference", "external-vault", "workload-identity"],
+      authoritySchemes: ["environment-reference", "client-encrypted", "external-vault", "workload-identity"],
       knowledgePageIds: ["provider.railway", "services.credentials", "vault.rotation"]
     }]
   },

package/dist/secrets-capability/service-vault-contracts.d.ts

@@ -2,6 +2,9 @@ export declare const SERVICE_VAULT_ENCRYPTION_VERSION: "service-vault-v1";
 export declare const SERVICE_VAULT_AEAD_ALGORITHM: "xchacha20-poly1305-ietf";
 export declare const SERVICE_VAULT_KEY_AGREEMENT: "x25519-sealed-box";
 export declare const SERVICE_VAULT_KDF: "argon2id";
+export declare const SECRET_OPERATION_PURPOSES: readonly ["provider-connection-validation", "remote-git-publication", "workflow-dispatch", "workflow-configuration", "hosted-topology-plan", "hosted-topology-apply", "hosted-topology-readback", "hosted-topology-rollback"];
+export type SecretOperationPurpose = (typeof SECRET_OPERATION_PURPOSES)[number];
+export type HostedSecretOperationPurpose = Extract<SecretOperationPurpose, `hosted-topology-${string}`>;
 export type EncryptedCredentialEnvelope = {
     version: typeof SERVICE_VAULT_ENCRYPTION_VERSION;
     algorithm: typeof SERVICE_VAULT_AEAD_ALGORITHM;
@@ -37,7 +40,7 @@ export type SecretOperationLease = {
     teamId: string;
     connectionId: string;
     capabilityType: string;
-    purpose: 'provider-connection-validation' | 'remote-git-publication' | 'workflow-dispatch' | 'workflow-configuration';
+    purpose: SecretOperationPurpose;
     resourceScope: Record<string, string>;
     credentialProfileId: string;
     actorUserId: string;
@@ -47,6 +50,47 @@ export type SecretOperationLease = {
     expiresAt: string;
     consumedAt?: string | null;
     operationCorrelationId: string;
+    hostedBinding?: HostedSecretOperationBinding;
+    authorityRequests?: SecretOperationAuthorityRequest[];
+};
+export type HostedSecretOperationBinding = {
+    subjectType: 'declaration' | 'plan' | 'rollback';
+    subjectDigest: string;
+    deploymentId: string;
+    stackId: string;
+    environment: 'staging' | 'production';
+};
+export type SecretOperationAuthorityRequest = {
+    requestId: string;
+    connectionId: string;
+    credentialProfileId: string;
+    provider: 'cloudflare' | 'railway' | 'treeseed';
+    purpose: 'provider' | 'state-backend' | 'state-encryption';
+    capabilities: string[];
+    requiredFields: string[];
+    secretRef?: string;
+};
+export type SealedSecretOperationPayload = {
+    schemaVersion: 'treeseed.sealed-secret-operation-payload/v1';
+    leaseId: string;
+    teamId: string;
+    operationCorrelationId: string;
+    hostedBinding: HostedSecretOperationBinding;
+    algorithm: typeof SERVICE_VAULT_KEY_AGREEMENT;
+    ciphertext: string;
+};
+export type SecretOperationCredentialBundle = {
+    schemaVersion: 'treeseed.secret-operation-credential-bundle/v1';
+    leaseId: string;
+    teamId: string;
+    operationCorrelationId: string;
+    hostedBinding: HostedSecretOperationBinding;
+    materials: Array<{
+        requestId: string;
+        connectionId: string;
+        credentialProfileId: string;
+        values: Record<string, string>;
+    }>;
 };
 export type ServiceVaultAssociatedData = {
     teamId: string;
@@ -58,4 +102,7 @@ export type ServiceVaultAssociatedData = {
 };
 export declare function containsForbiddenPlaintextSecretMaterial(value: unknown, path?: string): string[];
 export declare function canonicalServiceVaultAssociatedData(input: ServiceVaultAssociatedData): string;
+export declare function canonicalHostedSecretOperationBinding(input: HostedSecretOperationBinding): string;
+export declare function validateHostedSecretOperationBinding(value: unknown): value is HostedSecretOperationBinding;
+export declare function validateSealedSecretOperationPayload(value: unknown): value is SealedSecretOperationPayload;
 export declare function validateEncryptedCredentialEnvelope(value: unknown): value is EncryptedCredentialEnvelope;

package/dist/secrets-capability/service-vault-contracts.js

@@ -2,6 +2,16 @@ const SERVICE_VAULT_ENCRYPTION_VERSION = "service-vault-v1";
 const SERVICE_VAULT_AEAD_ALGORITHM = "xchacha20-poly1305-ietf";
 const SERVICE_VAULT_KEY_AGREEMENT = "x25519-sealed-box";
 const SERVICE_VAULT_KDF = "argon2id";
+const SECRET_OPERATION_PURPOSES = [
+  "provider-connection-validation",
+  "remote-git-publication",
+  "workflow-dispatch",
+  "workflow-configuration",
+  "hosted-topology-plan",
+  "hosted-topology-apply",
+  "hosted-topology-readback",
+  "hosted-topology-rollback"
+];
 const FORBIDDEN_SECRET_KEYS = /(?:passphrase|password|plaintext|derivedKey|privateKey|apiToken|accessToken|secretValue|credentialValue)$/iu;
 function containsForbiddenPlaintextSecretMaterial(value, path = "") {
   if (!value || typeof value !== "object") return [];
@@ -23,17 +33,42 @@ function canonicalServiceVaultAssociatedData(input) {
     version: input.version
   });
 }
+const digest = /^sha256:[a-f0-9]{64}$/u;
+const identifier = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+function canonicalHostedSecretOperationBinding(input) {
+  return JSON.stringify({
+    subjectType: input.subjectType,
+    subjectDigest: input.subjectDigest,
+    deploymentId: input.deploymentId,
+    stackId: input.stackId,
+    environment: input.environment
+  });
+}
+function validateHostedSecretOperationBinding(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const binding = value;
+  return ["declaration", "plan", "rollback"].includes(String(binding.subjectType)) && digest.test(String(binding.subjectDigest)) && identifier.test(String(binding.deploymentId)) && identifier.test(String(binding.stackId)) && ["staging", "production"].includes(String(binding.environment));
+}
+function validateSealedSecretOperationPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const payload = value;
+  return payload.schemaVersion === "treeseed.sealed-secret-operation-payload/v1" && payload.algorithm === SERVICE_VAULT_KEY_AGREEMENT && [payload.leaseId, payload.teamId, payload.operationCorrelationId, payload.ciphertext].every((field) => typeof field === "string" && field.length > 0) && validateHostedSecretOperationBinding(payload.hostedBinding);
+}
 function validateEncryptedCredentialEnvelope(value) {
   if (!value || typeof value !== "object") return false;
   const envelope = value;
   return envelope.version === SERVICE_VAULT_ENCRYPTION_VERSION && envelope.algorithm === SERVICE_VAULT_AEAD_ALGORITHM && [envelope.ciphertext, envelope.nonce, envelope.wrappedKey, envelope.wrappedKeyNonce, envelope.associatedData, envelope.associatedDataDigest, envelope.fingerprint].every((field) => typeof field === "string" && field.length > 0);
 }
 export {
+  SECRET_OPERATION_PURPOSES,
   SERVICE_VAULT_AEAD_ALGORITHM,
   SERVICE_VAULT_ENCRYPTION_VERSION,
   SERVICE_VAULT_KDF,
   SERVICE_VAULT_KEY_AGREEMENT,
+  canonicalHostedSecretOperationBinding,
   canonicalServiceVaultAssociatedData,
   containsForbiddenPlaintextSecretMaterial,
-  validateEncryptedCredentialEnvelope
+  validateEncryptedCredentialEnvelope,
+  validateHostedSecretOperationBinding,
+  validateSealedSecretOperationPayload
 };

package/dist/secrets-capability/service-vault-crypto.d.ts

@@ -0,0 +1,20 @@
+import { type EncryptedCredentialEnvelope, type EncryptedPrivateKeyEnvelope, type TeamVaultGrantEnvelope } from '@treeseed/sdk/secrets-capability';
+export declare function createServiceVaultKey(): Promise<Uint8Array>;
+export declare function createServiceVaultUserKeyPair(): Promise<{
+    publicKey: string;
+    privateKey: Uint8Array;
+}>;
+export declare function encryptServiceVaultPrivateKey(privateKey: Uint8Array, publicKey: string, passphrase: string, options?: {
+    opsLimit?: number;
+    memLimit?: number;
+}): Promise<EncryptedPrivateKeyEnvelope>;
+export declare function decryptServiceVaultPrivateKey(envelope: EncryptedPrivateKeyEnvelope, passphrase: string): Promise<Uint8Array>;
+export declare function createTeamVaultGrant(teamVaultKey: Uint8Array, recipientPublicKey: string): Promise<TeamVaultGrantEnvelope>;
+export declare function openTeamVaultGrant(grant: TeamVaultGrantEnvelope, recipientPrivateKey: Uint8Array): Promise<Uint8Array>;
+export declare function encryptServiceCredential(plaintext: string, teamVaultKey: Uint8Array, associatedData: string): Promise<EncryptedCredentialEnvelope>;
+export declare function decryptServiceCredential(envelope: EncryptedCredentialEnvelope, teamVaultKey: Uint8Array, expectedAssociatedData: string): Promise<string>;
+export declare function rewrapServiceCredential(envelope: EncryptedCredentialEnvelope, currentTeamVaultKey: Uint8Array, replacementTeamVaultKey: Uint8Array): Promise<EncryptedCredentialEnvelope>;
+export declare function sealSecretOperationPayload(values: Record<string, string>, operationPublicKey: string): Promise<string>;
+export declare function encryptGitHubActionsSecret(value: string, providerPublicKey: string): Promise<string>;
+export declare function openSecretOperationPayload(sealedPayload: string, operationPublicKey: string, operationPrivateKey: Uint8Array): Promise<Record<string, string>>;
+export declare function clearServiceVaultKey(value: Uint8Array | undefined): void;

package/dist/secrets-capability/service-vault-crypto.js

@@ -0,0 +1,210 @@
+import sodium from "libsodium-wrappers-sumo";
+import {
+  SERVICE_VAULT_AEAD_ALGORITHM,
+  SERVICE_VAULT_ENCRYPTION_VERSION,
+  SERVICE_VAULT_KDF,
+  SERVICE_VAULT_KEY_AGREEMENT
+} from "@treeseed/sdk/secrets-capability";
+const b64 = () => sodium.base64_variants.ORIGINAL;
+const encode = (value) => sodium.to_base64(value, b64());
+const decode = (value) => sodium.from_base64(value, b64());
+const hash = (value, key = null) => encode(sodium.crypto_generichash(32, value, key));
+async function ready() {
+  await sodium.ready;
+  return sodium;
+}
+function validKey(value, length, label) {
+  if (!(value instanceof Uint8Array) || value.length !== length) throw new Error(`${label} is invalid.`);
+  return value;
+}
+async function createServiceVaultKey() {
+  const crypto = await ready();
+  return crypto.randombytes_buf(crypto.crypto_aead_xchacha20poly1305_ietf_KEYBYTES);
+}
+async function createServiceVaultUserKeyPair() {
+  const crypto = await ready(), pair = crypto.crypto_box_keypair();
+  return { publicKey: encode(pair.publicKey), privateKey: pair.privateKey };
+}
+async function encryptServiceVaultPrivateKey(privateKey, publicKey, passphrase, options = {}) {
+  const crypto = await ready();
+  validKey(privateKey, crypto.crypto_box_SECRETKEYBYTES, "Service-vault private key");
+  validKey(decode(publicKey), crypto.crypto_box_PUBLICKEYBYTES, "Service-vault public key");
+  if (passphrase.length < 12) throw new Error("Service-vault passphrase must contain at least 12 characters.");
+  const salt = crypto.randombytes_buf(crypto.crypto_pwhash_SALTBYTES);
+  const opsLimit = options.opsLimit ?? crypto.crypto_pwhash_OPSLIMIT_MODERATE;
+  const memLimit = options.memLimit ?? crypto.crypto_pwhash_MEMLIMIT_MODERATE;
+  const key = crypto.crypto_pwhash(
+    crypto.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
+    passphrase,
+    salt,
+    opsLimit,
+    memLimit,
+    crypto.crypto_pwhash_ALG_ARGON2ID13
+  );
+  const nonce = crypto.randombytes_buf(crypto.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+  try {
+    return {
+      version: SERVICE_VAULT_ENCRYPTION_VERSION,
+      algorithm: SERVICE_VAULT_AEAD_ALGORITHM,
+      kdf: { algorithm: SERVICE_VAULT_KDF, opsLimit, memLimit, salt: encode(salt) },
+      nonce: encode(nonce),
+      ciphertext: encode(crypto.crypto_aead_xchacha20poly1305_ietf_encrypt(privateKey, publicKey, null, nonce, key)),
+      publicKey
+    };
+  } finally {
+    crypto.memzero(key);
+  }
+}
+async function decryptServiceVaultPrivateKey(envelope, passphrase) {
+  const crypto = await ready();
+  if (envelope.version !== SERVICE_VAULT_ENCRYPTION_VERSION || envelope.algorithm !== SERVICE_VAULT_AEAD_ALGORITHM || envelope.kdf.algorithm !== SERVICE_VAULT_KDF) throw new Error("Service-vault private-key envelope is unsupported.");
+  if (!Number.isSafeInteger(envelope.kdf.opsLimit) || !Number.isSafeInteger(envelope.kdf.memLimit) || envelope.kdf.opsLimit < crypto.crypto_pwhash_OPSLIMIT_INTERACTIVE || envelope.kdf.opsLimit > crypto.crypto_pwhash_OPSLIMIT_SENSITIVE || envelope.kdf.memLimit < crypto.crypto_pwhash_MEMLIMIT_INTERACTIVE || envelope.kdf.memLimit > crypto.crypto_pwhash_MEMLIMIT_SENSITIVE)
+    throw new Error("Service-vault private-key KDF parameters are invalid.");
+  const key = crypto.crypto_pwhash(
+    crypto.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
+    passphrase,
+    decode(envelope.kdf.salt),
+    envelope.kdf.opsLimit,
+    envelope.kdf.memLimit,
+    crypto.crypto_pwhash_ALG_ARGON2ID13
+  );
+  try {
+    return validKey(crypto.crypto_aead_xchacha20poly1305_ietf_decrypt(
+      null,
+      decode(envelope.ciphertext),
+      envelope.publicKey,
+      decode(envelope.nonce),
+      key
+    ), crypto.crypto_box_SECRETKEYBYTES, "Decrypted service-vault private key");
+  } catch {
+    throw new Error("Service-vault passphrase or private-key envelope is invalid.");
+  } finally {
+    crypto.memzero(key);
+  }
+}
+async function createTeamVaultGrant(teamVaultKey, recipientPublicKey) {
+  const crypto = await ready();
+  validKey(teamVaultKey, crypto.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "Team vault key");
+  const publicKey = validKey(decode(recipientPublicKey), crypto.crypto_box_PUBLICKEYBYTES, "Recipient public key");
+  return {
+    version: SERVICE_VAULT_ENCRYPTION_VERSION,
+    algorithm: SERVICE_VAULT_KEY_AGREEMENT,
+    recipientPublicKey,
+    wrappedTeamVaultKey: encode(crypto.crypto_box_seal(teamVaultKey, publicKey))
+  };
+}
+async function openTeamVaultGrant(grant, recipientPrivateKey) {
+  const crypto = await ready();
+  if (grant.version !== SERVICE_VAULT_ENCRYPTION_VERSION || grant.algorithm !== SERVICE_VAULT_KEY_AGREEMENT)
+    throw new Error("Team vault grant is unsupported.");
+  const publicKey = validKey(decode(grant.recipientPublicKey), crypto.crypto_box_PUBLICKEYBYTES, "Recipient public key");
+  validKey(recipientPrivateKey, crypto.crypto_box_SECRETKEYBYTES, "Recipient private key");
+  try {
+    return validKey(
+      crypto.crypto_box_seal_open(decode(grant.wrappedTeamVaultKey), publicKey, recipientPrivateKey),
+      crypto.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
+      "Unwrapped team vault key"
+    );
+  } catch {
+    throw new Error("Team vault grant cannot be opened by this user key.");
+  }
+}
+async function encryptServiceCredential(plaintext, teamVaultKey, associatedData) {
+  const crypto = await ready();
+  validKey(teamVaultKey, crypto.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "Team vault key");
+  if (!plaintext || !associatedData) throw new Error("Credential value and associated data are required.");
+  const dataKey = crypto.crypto_aead_xchacha20poly1305_ietf_keygen();
+  const nonce = crypto.randombytes_buf(crypto.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+  const wrappedKeyNonce = crypto.randombytes_buf(crypto.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+  try {
+    return {
+      version: SERVICE_VAULT_ENCRYPTION_VERSION,
+      algorithm: SERVICE_VAULT_AEAD_ALGORITHM,
+      ciphertext: encode(crypto.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, associatedData, null, nonce, dataKey)),
+      nonce: encode(nonce),
+      wrappedKey: encode(crypto.crypto_aead_xchacha20poly1305_ietf_encrypt(dataKey, associatedData, null, wrappedKeyNonce, teamVaultKey)),
+      wrappedKeyNonce: encode(wrappedKeyNonce),
+      associatedData,
+      associatedDataDigest: hash(associatedData),
+      fingerprint: hash(plaintext, teamVaultKey)
+    };
+  } finally {
+    crypto.memzero(dataKey);
+  }
+}
+async function decryptServiceCredential(envelope, teamVaultKey, expectedAssociatedData) {
+  const crypto = await ready();
+  validKey(teamVaultKey, crypto.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "Team vault key");
+  if (envelope.version !== SERVICE_VAULT_ENCRYPTION_VERSION || envelope.algorithm !== SERVICE_VAULT_AEAD_ALGORITHM || envelope.associatedData !== expectedAssociatedData || envelope.associatedDataDigest !== hash(expectedAssociatedData))
+    throw new Error("Credential envelope binding is invalid.");
+  let dataKey;
+  try {
+    dataKey = crypto.crypto_aead_xchacha20poly1305_ietf_decrypt(
+      null,
+      decode(envelope.wrappedKey),
+      expectedAssociatedData,
+      decode(envelope.wrappedKeyNonce),
+      teamVaultKey
+    );
+    return crypto.crypto_aead_xchacha20poly1305_ietf_decrypt(
+      null,
+      decode(envelope.ciphertext),
+      expectedAssociatedData,
+      decode(envelope.nonce),
+      dataKey,
+      "text"
+    );
+  } catch {
+    throw new Error("Credential envelope cannot be decrypted.");
+  } finally {
+    if (dataKey) crypto.memzero(dataKey);
+  }
+}
+async function rewrapServiceCredential(envelope, currentTeamVaultKey, replacementTeamVaultKey) {
+  const plaintext = await decryptServiceCredential(envelope, currentTeamVaultKey, envelope.associatedData);
+  return encryptServiceCredential(plaintext, replacementTeamVaultKey, envelope.associatedData);
+}
+async function sealSecretOperationPayload(values, operationPublicKey) {
+  const crypto = await ready();
+  if (!Object.keys(values).length || Object.values(values).some((value) => typeof value !== "string" || !value))
+    throw new Error("Secret operation payload must contain only non-empty string values.");
+  const payload = JSON.stringify(Object.fromEntries(Object.entries(values).sort(([left], [right]) => left.localeCompare(right))));
+  return encode(crypto.crypto_box_seal(payload, validKey(decode(operationPublicKey), crypto.crypto_box_PUBLICKEYBYTES, "Operation public key")));
+}
+async function encryptGitHubActionsSecret(value, providerPublicKey) {
+  const crypto = await ready();
+  if (!value) throw new Error("GitHub Actions secret value is required.");
+  return encode(crypto.crypto_box_seal(
+    value,
+    validKey(decode(providerPublicKey), crypto.crypto_box_PUBLICKEYBYTES, "GitHub public key")
+  ));
+}
+async function openSecretOperationPayload(sealedPayload, operationPublicKey, operationPrivateKey) {
+  const crypto = await ready();
+  try {
+    const plaintext = crypto.crypto_box_seal_open(decode(sealedPayload), decode(operationPublicKey), operationPrivateKey, "text");
+    const parsed = JSON.parse(plaintext);
+    if (!parsed || Array.isArray(parsed) || Object.values(parsed).some((value) => typeof value !== "string" || !value)) throw new Error();
+    return parsed;
+  } catch {
+    throw new Error("Secret operation payload cannot be opened.");
+  }
+}
+function clearServiceVaultKey(value) {
+  value?.fill(0);
+}
+export {
+  clearServiceVaultKey,
+  createServiceVaultKey,
+  createServiceVaultUserKeyPair,
+  createTeamVaultGrant,
+  decryptServiceCredential,
+  decryptServiceVaultPrivateKey,
+  encryptGitHubActionsSecret,
+  encryptServiceCredential,
+  encryptServiceVaultPrivateKey,
+  openSecretOperationPayload,
+  openTeamVaultGrant,
+  rewrapServiceCredential,
+  sealSecretOperationPayload
+};

package/dist/types/agents/agent-trigger-kinds.d.ts

@@ -184,5 +184,4 @@ export interface AgentActivityPlanningIntent {
         signals?: AgentSignalPolicy;
     }>;
     requiresArtifactKinds?: string[];
-    proposalTypes?: string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.81",
+  "version": "0.13.0-rc.83",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {
@@ -53,6 +53,7 @@
   "dependencies": {
     "@treeseed/treedx": "0.3.0-rc.4",
     "esbuild": "^0.28.0",
+    "libsodium-wrappers-sumo": "0.8.4",
     "typescript": "^5.9.3",
     "yaml": "^2.8.1",
     "zod": "^3.25.76"