@treeseed/sdk 0.13.0-rc.114 → 0.13.0-rc.116

package/dist/capacity-provider/source/candidate.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { sourceWorkspaceKeySchema } from "../source-workspace.js";
+const sourceCandidateChunkBytes = 524288;
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const commit = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u);
+const id = z.string().min(1).max(256);
+const sourceCandidateAttestationSchema = z.object({
+  schemaVersion: z.literal("treeseed.source-candidate-attestation/v1"),
+  providerId: id,
+  assignmentId: id,
+  attempt: z.number().int().positive(),
+  leaseId: id,
+  source: sourceWorkspaceKeySchema,
+  commit,
+  parentCandidateId: id.nullable(),
+  bundle: z.object({
+    digest,
+    bytes: z.number().int().positive().max(sourceCandidateChunkBytes * 1024),
+    chunks: z.array(digest).min(1).max(1024)
+  }).strict(),
+  verification: z.object({
+    clean: z.literal(true),
+    objectClosure: z.literal(true),
+    ancestry: z.literal(true),
+    isolatedVerifier: z.literal(true),
+    executionStopped: z.literal(true),
+    verifierStopped: z.literal(true)
+  }).strict(),
+  verifiedAt: z.string().datetime()
+}).strict().superRefine((value, context) => {
+  if (value.bundle.chunks.length !== Math.ceil(value.bundle.bytes / sourceCandidateChunkBytes)) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["bundle", "chunks"], message: "Candidate chunk count must match its bounded size." });
+  }
+});
+const signedSourceCandidateSchema = z.object({
+  attestation: sourceCandidateAttestationSchema,
+  signature: z.object({
+    algorithm: z.literal("Ed25519"),
+    keyId: id,
+    value: z.string().regex(/^[A-Za-z0-9_-]{86}$/u)
+  }).strict()
+}).strict();
+const authority = { runnerId: id, leaseToken: z.string().min(1).max(4096), candidate: signedSourceCandidateSchema };
+const sourceCandidateRequestSchema = z.discriminatedUnion("action", [
+  z.object({
+    ...authority,
+    action: z.literal("chunk"),
+    index: z.number().int().min(0).max(1023),
+    content: z.string().min(4).max(Math.ceil(sourceCandidateChunkBytes / 3) * 4).regex(/^[A-Za-z0-9+/]+={0,2}$/u)
+  }).strict(),
+  z.object({ ...authority, action: z.literal("commit") }).strict()
+]);
+const sourceChunkRequestSchema = z.object({
+  runnerId: id,
+  leaseToken: z.string().min(1).max(4096),
+  artifactId: id,
+  index: z.number().int().min(0).max(1023)
+}).strict();
+const sourceChunkResponseSchema = z.object({
+  artifactId: id,
+  index: z.number().int().min(0).max(1023),
+  digest,
+  content: z.string().min(4).max(Math.ceil(sourceCandidateChunkBytes / 3) * 4).regex(/^[A-Za-z0-9+/]+={0,2}$/u)
+}).strict();
+export {
+  signedSourceCandidateSchema,
+  sourceCandidateAttestationSchema,
+  sourceCandidateChunkBytes,
+  sourceCandidateRequestSchema,
+  sourceChunkRequestSchema,
+  sourceChunkResponseSchema
+};

package/dist/capacity-provider/source-workspace.d.ts

@@ -505,6 +505,23 @@ export declare const sourceWorkspaceResponseSchema: z.ZodEffects<z.ZodObject<{
         publication: "denied" | "candidate-only";
         credentialBindingId: string;
     }>;
+    /** Present only for an accepted predecessor candidate selected by the control plane. */
+    sourceBundle: z.ZodOptional<z.ZodObject<{
+        artifactId: z.ZodString;
+        digest: z.ZodString;
+        bytes: z.ZodNumber;
+        chunks: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        digest: string;
+        bytes: number;
+        artifactId: string;
+        chunks: string[];
+    }, {
+        digest: string;
+        bytes: number;
+        artifactId: string;
+        chunks: string[];
+    }>>;
     repository: z.ZodObject<{
         provider: z.ZodLiteral<"github">;
         owner: z.ZodString;
@@ -595,6 +612,12 @@ export declare const sourceWorkspaceResponseSchema: z.ZodEffects<z.ZodObject<{
         authorizationId: string;
         ephemeralPublicKey: string;
     };
+    sourceBundle?: {
+        digest: string;
+        bytes: number;
+        artifactId: string;
+        chunks: string[];
+    } | undefined;
 }, {
     repository: {
         provider: "github";
@@ -635,6 +658,12 @@ export declare const sourceWorkspaceResponseSchema: z.ZodEffects<z.ZodObject<{
         authorizationId: string;
         ephemeralPublicKey: string;
     };
+    sourceBundle?: {
+        digest: string;
+        bytes: number;
+        artifactId: string;
+        chunks: string[];
+    } | undefined;
 }>, {
     repository: {
         provider: "github";
@@ -675,6 +704,12 @@ export declare const sourceWorkspaceResponseSchema: z.ZodEffects<z.ZodObject<{
         authorizationId: string;
         ephemeralPublicKey: string;
     };
+    sourceBundle?: {
+        digest: string;
+        bytes: number;
+        artifactId: string;
+        chunks: string[];
+    } | undefined;
 }, {
     repository: {
         provider: "github";
@@ -715,6 +750,12 @@ export declare const sourceWorkspaceResponseSchema: z.ZodEffects<z.ZodObject<{
         authorizationId: string;
         ephemeralPublicKey: string;
     };
+    sourceBundle?: {
+        digest: string;
+        bytes: number;
+        artifactId: string;
+        chunks: string[];
+    } | undefined;
 }>;
 export type SourceCredentialDelivery = z.infer<typeof sourceCredentialDeliverySchema>;
 export type SourceWorkspaceRequest = z.infer<typeof sourceWorkspaceRequestSchema>;

package/dist/capacity-provider/source-workspace.js

@@ -75,6 +75,13 @@ const sourceCredentialDeliverySchema = z.object({
 }).strict();
 const sourceWorkspaceResponseSchema = z.object({
   authorization: sourceWorkspaceAuthorizationSchema,
+  /** Present only for an accepted predecessor candidate selected by the control plane. */
+  sourceBundle: z.object({
+    artifactId: id,
+    digest,
+    bytes: z.number().int().positive().max(536870912),
+    chunks: z.array(digest).min(1).max(1024)
+  }).strict().optional(),
   repository: z.object({
     provider: z.literal("github"),
     owner: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9-]{0,99}$/u),
@@ -84,6 +91,9 @@ const sourceWorkspaceResponseSchema = z.object({
   }).strict(),
   credential: sourceCredentialDeliverySchema
 }).strict().superRefine((value, context) => {
+  if (value.sourceBundle && value.sourceBundle.chunks.length !== Math.ceil(value.sourceBundle.bytes / 524288)) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["sourceBundle"], message: "Source bundle chunks must match its bounded size." });
+  }
   if (value.repository.cloneUrl !== `https://github.com/${value.repository.owner}/${value.repository.name}.git`) {
     context.addIssue({ code: z.ZodIssueCode.custom, path: ["repository", "cloneUrl"], message: "Source transport must match its provider repository." });
   }

package/dist/content/validation/content-model-schemas.d.ts

@@ -2090,7 +2090,7 @@ declare const schemas: {
         related_books?: string[] | undefined;
         primary_contributor?: string | undefined;
         related_notes?: string[] | undefined;
-        decision_type?: "approved" | "rejected" | "deferred" | "superseded" | "request_changes" | undefined;
+        decision_type?: "approved" | "rejected" | "superseded" | "deferred" | "request_changes" | undefined;
         rationale?: string | undefined;
     }, {
         title: string;
@@ -2108,7 +2108,7 @@ declare const schemas: {
         related_books?: string[] | undefined;
         primary_contributor?: string | undefined;
         related_notes?: string[] | undefined;
-        decision_type?: "approved" | "rejected" | "deferred" | "superseded" | "request_changes" | undefined;
+        decision_type?: "approved" | "rejected" | "superseded" | "deferred" | "request_changes" | undefined;
         rationale?: string | undefined;
     }>;
     book: z.ZodObject<{
@@ -11915,7 +11915,7 @@ export declare function validateContentFrontmatter(model: PortableContentModel,
         related_books?: string[] | undefined;
         primary_contributor?: string | undefined;
         related_notes?: string[] | undefined;
-        decision_type?: "approved" | "rejected" | "deferred" | "superseded" | "request_changes" | undefined;
+        decision_type?: "approved" | "rejected" | "superseded" | "deferred" | "request_changes" | undefined;
         rationale?: string | undefined;
     } | {
         status: "review" | "archived" | "draft" | "published";
@@ -21630,7 +21630,7 @@ export declare function describeContentFrontmatterSchema(model: PortableContentM
     related_books?: string[] | undefined;
     primary_contributor?: string | undefined;
     related_notes?: string[] | undefined;
-    decision_type?: "approved" | "rejected" | "deferred" | "superseded" | "request_changes" | undefined;
+    decision_type?: "approved" | "rejected" | "superseded" | "deferred" | "request_changes" | undefined;
     rationale?: string | undefined;
 }, {
     title: string;
@@ -21648,7 +21648,7 @@ export declare function describeContentFrontmatterSchema(model: PortableContentM
     related_books?: string[] | undefined;
     primary_contributor?: string | undefined;
     related_notes?: string[] | undefined;
-    decision_type?: "approved" | "rejected" | "deferred" | "superseded" | "request_changes" | undefined;
+    decision_type?: "approved" | "rejected" | "superseded" | "deferred" | "request_changes" | undefined;
     rationale?: string | undefined;
 }> | z.ZodObject<{
     schemaVersion: z.ZodLiteral<"treeseed.book/v2">;

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

@@ -2001,7 +2001,7 @@ export declare function validatePortableContentData(model: string, value: unknow
         related_books?: string[] | undefined;
         primary_contributor?: string | undefined;
         related_notes?: string[] | undefined;
-        decision_type?: "approved" | "rejected" | "deferred" | "superseded" | "request_changes" | undefined;
+        decision_type?: "approved" | "rejected" | "superseded" | "deferred" | "request_changes" | undefined;
         rationale?: string | undefined;
     } | {
         status: "review" | "archived" | "draft" | "published";

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

@@ -1,6 +1,7 @@
 import { commandPaths } from "./catalog/infrastructure/command-tree-paths.js";
 import { managedSecretCommands } from "./catalog/services/secret-commands.js";
 import { identityLoginCommand } from "./catalog/services/identity-commands.js";
+import { WORKDAY_PROFILE_COMMAND_BINDINGS } from "./catalog/workdays/profile-commands.js";
 import { hostProviderEnvironmentBranch, PROVIDER_ENVIRONMENT_COMMAND_BINDINGS, providerEnvironmentBranches } from "./catalog/provider-environment-commands.js";
 const unavailable = (reason = "This capability is not enabled until its control-plane operation is accepted.") => ({
   kind: "unavailable",
@@ -132,6 +133,7 @@ const operationBindings = {
   "plans list": operation("plans.list", [field("path", "decisionId", "option", "decision", true), ...page()]),
   "plans show": operation("plans.show", [field("path", "capacityPlanId", "argument", "plan", true)]),
   "workdays plan": operation("workdays.plan", [field("path", "teamId", "context", "team", true), field("body", "profileId", "option", "profile"), field("body", "projects", "option", "projects", false, "csv"), field("body", "startsAt", "option", "start"), field("body", "endsAt", "option", "end"), field("body", "durationSeconds", "option", "duration", false, "integer"), field("body", "objectiveFilters", "option", "objective", false, "csv")]),
+  ...WORKDAY_PROFILE_COMMAND_BINDINGS,
   "workdays start": operation("workdays.start", [field("path", "teamId", "context", "team", true), field("body", "preflightId", "option", "preflight", true), field("body", "preflightDigest", "option", "digest", true)]),
   "workdays list": operation("workdays.list", [field("path", "teamId", "context", "team", true), ...page()]),
   "workdays show": operation("workdays.show", [field("path", "teamId", "context", "team", true), field("path", "runId", "argument", "workday", true)]),
@@ -454,7 +456,7 @@ const commandTree = {
     branch("capacity", [leaf("status"), leaf("explain"), leaf("usage"), leaf("ledger"), leaf("audit")]),
     branch("plans", [leaf("list"), leaf("show", "read", "plan"), leaf("explain", "read", "plan"), { nodeType: "leaf", segment: "diff", description: "Compare two API-derived plans.", kind: "read", arguments: [{ name: "left", description: "Left plan identity.", required: true }, { name: "right", description: "Right plan identity.", required: true }], resultSchemaId: "treeseed.command.plans.diff/v1", execution: unavailable() }]),
     branch("workdays", [
-      branch("profiles", [leaf("list"), leaf("show", "read", "profile"), leaf("validate", "read", "file")]),
+      branch("profiles", [leaf("list"), leaf("show", "read", "profile"), leaf("reconcile", "mutation", "project", "authority"), leaf("validate", "read", "file")]),
       leaf("plan", "mutation"),
       leaf("start", "mutation", void 0, "authority"),
       leaf("list"),

package/dist/operator-contracts/catalog/workdays/profile-commands.d.ts

@@ -0,0 +1,4 @@
+import type { CommandLeafDescriptor } from '../../command-tree.js';
+type Execution = CommandLeafDescriptor['execution'];
+export declare const WORKDAY_PROFILE_COMMAND_BINDINGS: Record<string, Execution>;
+export {};

package/dist/operator-contracts/catalog/workdays/profile-commands.js

@@ -0,0 +1,20 @@
+const team = { target: "path", field: "teamId", source: "context", name: "team", required: true, transform: "identity" };
+const WORKDAY_PROFILE_COMMAND_BINDINGS = {
+  "workdays profiles list": { kind: "operation", operationId: "workdays.profiles.list", input: [
+    team,
+    { target: "query", field: "limit", source: "option", name: "limit", transform: "integer" },
+    { target: "query", field: "cursor", source: "option", name: "cursor", transform: "identity" },
+    { target: "query", field: "status", source: "option", name: "status", transform: "identity" }
+  ] },
+  "workdays profiles show": { kind: "operation", operationId: "workdays.profiles.show", input: [
+    team,
+    { target: "path", field: "profileId", source: "argument", name: "profile", required: true, transform: "identity" }
+  ] },
+  "workdays profiles reconcile": { kind: "operation", operationId: "workdays.profiles.reconcile", input: [
+    team,
+    { target: "path", field: "projectId", source: "argument", name: "project", required: true, transform: "identity" }
+  ] }
+};
+export {
+  WORKDAY_PROFILE_COMMAND_BINDINGS
+};

package/dist/operator-contracts/catalog/workdays/profile-operations.d.ts

@@ -0,0 +1,16 @@
+export declare const WORKDAY_PROFILE_OPERATIONS: {
+    profilesList: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }, undefined, Record<string, unknown>>;
+    profilesShow: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }, undefined, Record<string, unknown>>;
+    profilesReconcile: import("../../control-plane-operation.js").ControlPlaneOperationBinding<{
+        projectId: string;
+        teamId: string;
+    }, {}, {}, Record<string, unknown>>;
+};

package/dist/operator-contracts/catalog/workdays/profile-operations.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { defineOperation } from "../../operation-builder.js";
+const team = z.object({ teamId: z.string().min(1) }).strict();
+const empty = z.object({}).strict();
+const output = z.record(z.unknown());
+const read = (operationId, path, parameters, query, pagination) => defineOperation({
+  operationId,
+  description: "Read accepted repository workday profile generations.",
+  rest: { method: "GET", path },
+  parameters: `treeseed.${operationId}.parameters/v1`,
+  capability: "workdays.read",
+  authentication: "oauth",
+  oauthScopes: ["treeseed:read"],
+  kind: "read",
+  riskClass: "ordinary",
+  confirmation: "never",
+  surfaces: ["rest", "cli"],
+  cacheScope: "principal",
+  pagination
+}, { path: parameters, query, body: z.undefined(), output });
+const WORKDAY_PROFILE_OPERATIONS = {
+  profilesList: read(
+    "workdays.profiles.list",
+    "/v1/teams/{teamId}/workday-profiles",
+    team,
+    z.object({ limit: z.coerce.number().int().min(1).max(100).optional(), cursor: z.string().optional(), status: z.enum(["active", "archived", "superseded"]).optional() }).strict(),
+    "cursor"
+  ),
+  profilesShow: read("workdays.profiles.show", "/v1/teams/{teamId}/workday-profiles/{profileId}", team.extend({ profileId: z.string().min(1) }), empty, "none"),
+  profilesReconcile: defineOperation({
+    operationId: "workdays.profiles.reconcile",
+    description: "Reconcile a bound repository profile after exact successful source verification.",
+    rest: { method: "POST", path: "/v1/teams/{teamId}/projects/{projectId}/workday-profiles/reconcile" },
+    parameters: "treeseed.workdays.profiles.reconcile.parameters/v1",
+    capability: "workdays.execute",
+    authentication: "oauth",
+    oauthScopes: ["treeseed:execution"],
+    kind: "mutation",
+    riskClass: "authority",
+    confirmation: "input_required",
+    surfaces: ["rest", "cli"],
+    cacheScope: "none",
+    pagination: "none"
+  }, { path: team.extend({ projectId: z.string().min(1) }), query: empty, body: empty, output })
+};
+export {
+  WORKDAY_PROFILE_OPERATIONS
+};

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

@@ -2004,6 +2004,20 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             teamId: string;
             scheduleId: string;
         }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly profilesList: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+            [x: string]: any;
+        }, {
+            [x: string]: any;
+        }, undefined, Record<string, unknown>>;
+        readonly profilesShow: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+            [x: string]: any;
+        }, {
+            [x: string]: any;
+        }, undefined, Record<string, unknown>>;
+        readonly profilesReconcile: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+            projectId: string;
+            teamId: string;
+        }, {}, {}, Record<string, unknown>>;
     };
     readonly assignments: {
         readonly list: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
@@ -2573,6 +2587,9 @@ export declare const CONTROL_PLANE_OPERATIONS: {
         readonly sourceCandidate: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
             assignmentId: string;
         }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly sourceChunk: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+            assignmentId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
         readonly renewAssignment: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
             assignmentId: string;
         }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;

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

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { defineOperation as define, defineTreeDxProxyOperation as treedxProxy, defineReadOperation as read } from "./operation-builder.js";
 import { communicationOperations, providerCommunicationLifecycleOperations, providerDiscussionResponseOperation } from "./catalog/communication-operations.js";
 import { inboxOperations } from "./catalog/inbox-operations.js";
+import { WORKDAY_PROFILE_OPERATIONS } from "./catalog/workdays/profile-operations.js";
 import { adminAccountOperations, adminTeamOperations } from "./catalog/admin-account-team-operations.js";
 import { TREEAI_CONTROL_PLANE_OPERATIONS } from "./catalog/treeai-operations.js";
 import { capabilityOntologyOperations } from "./catalog/capability-ontology-operations.js";
@@ -305,6 +306,7 @@ const CONTROL_PLANE_OPERATIONS = {
     show: resource("plans.show", "GET", "/v1/capacity-plans/{capacityPlanId}", { capacityPlanId: z.string().min(1) }, { capability: "plans.read", surfaces: ["rest", "cli", "mcp_resource"] })
   },
   workdays: {
+    ...WORKDAY_PROFILE_OPERATIONS,
     list: resource("workdays.list", "GET", "/v1/teams/{teamId}/workday-runs", { teamId: z.string().min(1) }, { capability: "workdays.read", surfaces: ["rest", "cli", "mcp_tool"], pagination: "cursor" }),
     preflight: resource("workdays.plan", "POST", "/v1/teams/{teamId}/workday-runs/preflight", { teamId: z.string().min(1) }, { capability: "workdays.execute", scopes: ["treeseed:execution"], surfaces: ["rest", "cli", "mcp_tool"] }),
     start: resource("workdays.start", "POST", "/v1/teams/{teamId}/workday-runs", { teamId: z.string().min(1) }, { capability: "workdays.execute", scopes: ["treeseed:execution"], surfaces: ["rest", "cli", "mcp_tool"], risk: "authority" }),
@@ -482,7 +484,8 @@ const CONTROL_PLANE_OPERATIONS = {
     assignment: providerPath("providers.assignments.show", "GET", "/v1/provider/assignments/{assignmentId}", { assignmentId: z.string().min(1) }, { read: true }),
     assignmentExplanation: providerPath("providers.assignments.explain", "GET", "/v1/provider/assignments/{assignmentId}/explanation", { assignmentId: z.string().min(1) }, { read: true }),
     sourceWorkspace: providerPath("providers.assignments.source.authorize", "POST", "/v1/provider/assignments/{assignmentId}/source-workspace", { assignmentId: z.string().min(1) }, { redactedPaths: ["body.leaseToken", "output.credential.ciphertext"] }),
-    sourceCandidate: providerPath("providers.assignments.source.candidate", "POST", "/v1/provider/assignments/{assignmentId}/source-candidates", { assignmentId: z.string().min(1) }, { redactedPaths: ["body.leaseToken"] }),
+    sourceCandidate: providerPath("providers.assignments.source.candidate", "POST", "/v1/provider/assignments/{assignmentId}/source-candidates", { assignmentId: z.string().min(1) }, { redactedPaths: ["body.leaseToken", "body.content"] }),
+    sourceChunk: providerPath("providers.assignments.source.chunk", "POST", "/v1/provider/assignments/{assignmentId}/source-workspace/chunks", { assignmentId: z.string().min(1) }, { redactedPaths: ["body.leaseToken", "output.content"] }),
     renewAssignment: providerPath("providers.assignments.renew", "POST", "/v1/provider/assignments/{assignmentId}/renew", { assignmentId: z.string().min(1) }),
     startExecution: providerPath("providers.assignments.execution.start", "POST", "/v1/provider/assignments/{assignmentId}/execution-start", { assignmentId: z.string().min(1) }),
     startCloseout: providerPath("providers.assignments.closeout.start", "POST", "/v1/provider/assignments/{assignmentId}/closeout-start", { assignmentId: z.string().min(1) }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.114",
+  "version": "0.13.0-rc.116",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {