@treeseed/sdk 0.13.0-rc.12 → 0.13.0-rc.121

package/dist/content/validation/content-model-schemas.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { agentDefinitionSchema } from "../../agent-capacity/validation/agent-definition-schema.js";
-import { PROPOSAL_TYPE_ID_PATTERN } from "../../agent-capacity/validation/proposal-type.js";
 import {
   BOOK_SCHEMA_VERSION,
   KNOWLEDGE_PAGE_SCHEMA_VERSION,
@@ -9,6 +8,7 @@ import {
 } from "../../knowledge/contracts.js";
 import { auxiliaryContentSchemas } from "./auxiliary-content-schemas.js";
 import { agentOperationalContentSchemas } from "./agent-operational-content-schemas.js";
+import { exactEntityReferenceSchema, estimateSchema } from "../../agent-capacity/contracts/capacity/assignments/agent-execution.js";
 import { agentTestContentSchema, templateProductContentSchema, workdayContentSchema } from "./auxiliary-content-schemas.js";
 export * from "./agent-operational-content-schemas.js";
 const nonEmpty = z.string().trim().min(1);
@@ -16,7 +16,7 @@ const strings = z.array(z.string());
 const date = z.coerce.date();
 const lifecycleStatus = z.enum(["live", "in progress", "exploratory", "planned", "speculative"]);
 const contributor = nonEmpty;
-const entityRefs = z.array(z.object({ model: nonEmpty, id: nonEmpty, commitSha: nonEmpty.optional() }).strict()).optional();
+const exactRefs = z.array(exactEntityReferenceSchema);
 const linked = {
   group_ids: strings.optional(),
   related_objectives: strings.optional(),
@@ -48,6 +48,90 @@ const proposalPlanSchema = z.object({
   verification: strings,
   openQuestions: strings.optional()
 });
+const proposalLinks = {
+  related_notes: strings.optional(),
+  evidence_refs: strings.optional(),
+  decision_dependencies: z.array(z.object({ projectId: nonEmpty, decisionId: nonEmpty }).strict()).optional(),
+  ...linked
+};
+const executionPlanWorkItemSchema = z.object({
+  id: nonEmpty.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+  activity: z.literal("acting"),
+  agentClass: nonEmpty.regex(/^[a-z][a-z0-9-]*$/u),
+  workspace: z.enum(["read-only", "treedx", "git"]),
+  review: z.enum(["required", "none"]),
+  objective: nonEmpty,
+  estimate: estimateSchema.optional(),
+  reviewEstimate: estimateSchema.optional(),
+  maximumReviewCycles: z.number().int().positive().optional(),
+  dependsOn: z.array(nonEmpty.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u)),
+  requestedPermissions: z.object({
+    content: z.object({ read: z.array(z.enum(["agent", "book", "knowledge", "objective", "discussion", "discussion-message", "proposal", "question", "note", "decision"])), write: z.array(z.enum(["agent", "book", "knowledge", "objective", "discussion", "discussion-message", "proposal", "question", "note", "decision"])) }).strict(),
+    tools: z.array(z.enum(["discussion", "source.read", "source.write", "verification", "release"]))
+  }).strict(),
+  requiredCapabilities: z.array(nonEmpty).min(1),
+  contextRefs: z.array(exactEntityReferenceSchema).optional(),
+  acceptanceCriteria: z.array(nonEmpty).min(1)
+}).strict().superRefine((value, context) => {
+  if (value.review === "required" && !value.maximumReviewCycles) context.addIssue({ code: z.ZodIssueCode.custom, message: "Required review needs a maximum cycle count." });
+  if (value.review === "none" && (value.reviewEstimate || value.maximumReviewCycles)) context.addIssue({ code: z.ZodIssueCode.custom, message: "Unreviewed work cannot define review estimates or cycles." });
+  if (value.workspace !== "read-only") {
+    const mutable = (value.contextRefs ?? []).filter((reference) => reference.store === value.workspace);
+    if (mutable.length !== 1) context.addIssue({ code: z.ZodIssueCode.custom, path: ["contextRefs"], message: `${value.workspace} work requires exactly one exact ${value.workspace} workspace reference.` });
+  }
+});
+const executionPlanSchema = z.object({ workItems: z.array(executionPlanWorkItemSchema).min(1) }).strict().superRefine((value, context) => {
+  const ids = new Set(value.workItems.map((item) => item.id));
+  if (ids.size !== value.workItems.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Work-item IDs must be unique." });
+  for (const [index, item] of value.workItems.entries()) for (const dependency of item.dependsOn) {
+    if (!ids.has(dependency)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["workItems", index, "dependsOn"], message: `Dependency ${dependency} does not exist in this proposal.` });
+    if (dependency === item.id) context.addIssue({ code: z.ZodIssueCode.custom, path: ["workItems", index, "dependsOn"], message: "Work items cannot depend on themselves." });
+  }
+  const byId = new Map(value.workItems.map((item) => [item.id, item]));
+  const visiting = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set();
+  const cyclic = (id) => {
+    if (visiting.has(id)) return true;
+    if (visited.has(id)) return false;
+    visiting.add(id);
+    if ((byId.get(id)?.dependsOn ?? []).some(cyclic)) return true;
+    visiting.delete(id);
+    visited.add(id);
+    return false;
+  };
+  if ([...ids].some(cyclic)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["workItems"], message: "Work-item dependencies must be acyclic." });
+});
+const proposalSchema = z.object({
+  schemaVersion: z.literal("treeseed.proposal/v1"),
+  id: nonEmpty,
+  projectId: nonEmpty,
+  title: nonEmpty,
+  request: nonEmpty,
+  summary: nonEmpty.optional(),
+  status: z.enum(["draft", "discussing", "ready", "decided", "withdrawn"]),
+  objectiveRefs: z.array(exactEntityReferenceSchema).optional(),
+  evidenceRefs: z.array(exactEntityReferenceSchema).optional(),
+  discussionRef: exactEntityReferenceSchema.optional(),
+  executionPlan: executionPlanSchema.optional()
+}).strict().superRefine((value, context) => {
+  if (["ready", "decided"].includes(value.status)) for (const [index, item] of (value.executionPlan?.workItems ?? []).entries()) {
+    if (!item.estimate) context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["executionPlan", "workItems", index, "estimate"],
+      message: "Ready work requires its agent-authored estimate."
+    });
+    if (item.review === "required" && !item.reviewEstimate) context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["executionPlan", "workItems", index, "reviewEstimate"],
+      message: "Ready reviewed work requires its Reviewer-authored estimate."
+    });
+  }
+  if (["ready", "decided"].includes(value.status) && !value.summary) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["summary"], message: "A ready proposal requires a summary." });
+  }
+  if (["ready", "decided"].includes(value.status) && !value.executionPlan) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["executionPlan"], message: "A ready proposal requires an execution plan." });
+  }
+});
 const schemas = {
   page: z.object({
     title: nonEmpty,
@@ -61,21 +145,32 @@ const schemas = {
     updated_at: date.optional()
   }),
   note: z.object({
-    ...governanceBase,
-    author: nonEmpty.optional(),
-    feedback_kind: z.enum(["support", "concern", "question", "response"]).optional(),
-    entity_refs: entityRefs,
-    about: strings.optional(),
-    ...linked
+    schemaVersion: z.literal("treeseed.note/v1"),
+    id: nonEmpty,
+    projectId: nonEmpty,
+    classification: z.enum(["general", "feedback", "research", "workday-report"]),
+    subjectRefs: exactRefs.min(1),
+    body: nonEmpty,
+    createdAt: z.string().datetime({ offset: true })
+  }).strict().superRefine((value, context) => {
+    if (value.classification === "workday-report" && !value.subjectRefs.some((reference) => reference.store === "postgresql" && reference.model === "workday")) {
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["subjectRefs"], message: "Workday reports must reference their exact workday." });
+    }
   }),
   question: z.object({
-    ...governanceBase,
-    question_type: z.enum(["research", "implementation", "strategy", "evaluation", "knowledge-gap"]).optional(),
-    motivation: nonEmpty.optional(),
-    primary_contributor: contributor.optional(),
-    entity_refs: entityRefs,
-    about: strings.optional(),
-    ...linked
+    schemaVersion: z.literal("treeseed.question/v1"),
+    id: nonEmpty,
+    projectId: nonEmpty,
+    subjectRef: exactEntityReferenceSchema,
+    question: nonEmpty,
+    status: z.enum(["open", "answered", "withdrawn"]),
+    addressedTo: strings.optional(),
+    answer: nonEmpty.optional(),
+    answerRefs: exactRefs.optional(),
+    askedAt: z.string().datetime({ offset: true }),
+    answeredAt: z.string().datetime({ offset: true }).optional()
+  }).strict().superRefine((value, context) => {
+    if (value.status === "answered" && !(value.answer || value.answerRefs?.length)) context.addIssue({ code: z.ZodIssueCode.custom, message: "Answered questions require an answer or exact answer reference." });
   }),
   objective: z.object({
     ...governanceBase,
@@ -84,29 +179,25 @@ const schemas = {
     primary_contributor: contributor.optional(),
     ...linked
   }),
-  proposal: z.object({
-    ...governanceBase,
-    description: nonEmpty,
-    date,
-    status: lifecycleStatus,
-    summary: nonEmpty,
-    proposal_type: nonEmpty.regex(PROPOSAL_TYPE_ID_PATTERN, "Proposal type must use lowercase kebab-case."),
-    motivation: nonEmpty,
-    primary_contributor: contributor,
-    related_notes: strings.optional(),
-    evidence_refs: strings.optional(),
-    plan: proposalPlanSchema.optional(),
-    decision_dependencies: z.array(z.object({ projectId: nonEmpty, decisionId: nonEmpty }).strict()).optional(),
-    ...linked
-  }),
+  proposal: proposalSchema,
   decision: z.object({
-    ...governanceBase,
-    decision_type: z.enum(["approved", "rejected", "deferred", "request_changes", "superseded"]).optional(),
-    rationale: nonEmpty.optional(),
-    authority: nonEmpty.optional(),
-    primary_contributor: contributor.optional(),
-    related_notes: strings.optional(),
-    ...linked
+    schemaVersion: z.literal("treeseed.decision/v1"),
+    id: nonEmpty,
+    projectId: nonEmpty,
+    decisionClass: z.enum(["proposal", "work-review", "publication"]),
+    decisionMethod: z.enum(["authority", "approval", "vote"]),
+    subjectRef: exactEntityReferenceSchema,
+    disposition: z.enum(["approved", "rejected", "request-changes", "deferred", "superseded"]),
+    rationale: nonEmpty,
+    findingRefs: exactRefs.optional(),
+    authorityRefs: exactRefs.min(1),
+    decidedByRefs: exactRefs.min(1),
+    positions: z.array(z.object({ actorRef: exactEntityReferenceSchema, position: z.enum(["approve", "reject", "abstain"]), rationale: z.string().optional(), recordedAt: z.string().datetime({ offset: true }) }).strict()).min(1).optional(),
+    decidedAt: z.string().datetime({ offset: true })
+  }).strict().superRefine((value, context) => {
+    if (value.decisionMethod !== "authority" && !value.positions?.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["positions"], message: "Approval and vote decisions require signed positions." });
+    if (value.decisionClass === "work-review" && !["approved", "request-changes"].includes(value.disposition)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["disposition"], message: "Work review must approve or request changes." });
+    if (value.decisionClass !== "work-review" && value.disposition === "request-changes") context.addIssue({ code: z.ZodIssueCode.custom, path: ["disposition"], message: "Only work review may request changes." });
   }),
   book: z.object({
     schemaVersion: z.literal(BOOK_SCHEMA_VERSION),
@@ -233,15 +324,26 @@ function describeContentFrontmatterSchema(model) {
 function fieldContract(schema) {
   let current = schema;
   let required = true;
-  if (current instanceof z.ZodOptional) {
-    required = false;
-    current = current.unwrap();
+  while (current instanceof z.ZodOptional || current instanceof z.ZodNullable || current instanceof z.ZodDefault || current instanceof z.ZodEffects) {
+    if (current instanceof z.ZodOptional || current instanceof z.ZodDefault) required = false;
+    current = current instanceof z.ZodEffects ? current.innerType() : current.removeDefault?.() ?? current.unwrap();
   }
-  if (current instanceof z.ZodNullable) current = current.unwrap();
   const contract = { required };
   if (current instanceof z.ZodEnum) return { ...contract, type: "string", values: current.options };
   if (current instanceof z.ZodLiteral) return { ...contract, type: typeof current.value, value: current.value };
-  if (current instanceof z.ZodString) return { ...contract, type: "string" };
+  if (current instanceof z.ZodString) {
+    const checks = current._def.checks;
+    const minimum = checks.find((check) => check.kind === "min")?.value;
+    const maximum = checks.find((check) => check.kind === "max")?.value;
+    const pattern = checks.find((check) => check.kind === "regex")?.regex?.source;
+    return {
+      ...contract,
+      type: "string",
+      ...minimum !== void 0 ? { minLength: minimum } : {},
+      ...maximum !== void 0 ? { maxLength: maximum } : {},
+      ...pattern ? { pattern } : {}
+    };
+  }
   if (current instanceof z.ZodNumber) return { ...contract, type: "number" };
   if (current instanceof z.ZodBoolean) return { ...contract, type: "boolean" };
   if (current instanceof z.ZodDate) return { ...contract, type: "date" };
@@ -254,15 +356,42 @@ function fieldContract(schema) {
   return { ...contract, type: current._def.typeName ?? "unknown" };
 }
 function describeContentFrontmatterContract(model) {
-  const schema = schemas[model];
+  const selected = schemas[model];
+  const schema = selected instanceof z.ZodEffects ? selected.innerType() : selected;
+  if (!(schema instanceof z.ZodObject)) throw new Error(`Content model ${model} is not an object schema.`);
   return {
     model,
     fields: Object.fromEntries(Object.entries(schema.shape).map(([name, value]) => [name, fieldContract(value)]))
   };
 }
+function contractJsonSchema(contract) {
+  const type = contract.type;
+  if (type === "object") {
+    const fields = contract.fields;
+    return {
+      type: "object",
+      additionalProperties: false,
+      properties: Object.fromEntries(Object.entries(fields).map(([name, field]) => {
+        const schema = contractJsonSchema(field);
+        return [name, field.required === true ? schema : { anyOf: [schema, { type: "null" }] }];
+      })),
+      required: Object.keys(fields)
+    };
+  }
+  if (type === "array") return { type: "array", items: contractJsonSchema(contract.items) };
+  if (contract.value !== void 0) return { type, const: contract.value };
+  if (Array.isArray(contract.values)) return { type, enum: contract.values };
+  if (type === "date") return { type: "string", format: "date-time" };
+  return Object.fromEntries(Object.entries(contract).filter(([name]) => !["required", "fields", "items"].includes(name)));
+}
+function describeContentFrontmatterJsonSchema(model) {
+  const contract = describeContentFrontmatterContract(model);
+  return contractJsonSchema({ required: true, type: "object", fields: contract.fields });
+}
 export {
   agentTestContentSchema,
   describeContentFrontmatterContract,
+  describeContentFrontmatterJsonSchema,
   describeContentFrontmatterSchema,
   isPortableContentModel,
   templateProductContentSchema,