@treeseed/sdk 0.13.0-rc.118 → 0.13.0-rc.119

package/dist/agent-capacity/contracts/support/execution-graph.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { activityProfileSchema } from "../../validation/agent-definition-schema.js";
+import { estimateSchema, exactEntityReferenceSchema } from "../capacity/assignments/agent-execution.js";
+const identifier = z.string().trim().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u);
+const slug = z.string().trim().min(1).max(100).regex(/^[a-z0-9]+(?:[._/-][a-z0-9]+)*$/u);
+const uniqueIds = z.array(identifier).superRefine((items, context) => {
+  if (new Set(items).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
+});
+const conditionDefinitionSchema = z.object({
+  conditionType: z.enum(["question", "external", "authority", "lifecycle"]),
+  subjectRef: exactEntityReferenceSchema,
+  expectedState: identifier
+}).strict();
+const executionNodeSchema = z.object({
+  schemaVersion: z.literal("treeseed.execution-node/v1"),
+  id: identifier,
+  teamId: identifier,
+  projectId: identifier,
+  workdayId: identifier.optional(),
+  workItemId: slug.optional(),
+  kind: z.enum(["planning", "estimating", "acting", "reviewing", "reporting", "communication", "condition"]),
+  pairRole: z.enum(["actor", "reviewer"]).nullable(),
+  sourceRef: exactEntityReferenceSchema,
+  authorityRefs: z.array(exactEntityReferenceSchema).optional(),
+  ruleRevision: z.number().int().positive(),
+  nodeRevision: z.number().int().positive(),
+  agentClass: z.string().regex(/^[a-z][a-z0-9-]*$/u).optional(),
+  status: z.enum(["proposed", "blocked", "ready", "assigned", "running", "completed", "failed", "cancelled", "stale"]),
+  estimate: estimateSchema.optional(),
+  requiredCapabilities: uniqueIds.optional(),
+  requestedPermissions: activityProfileSchema.shape.permissions.optional(),
+  workspace: z.enum(["read-only", "treedx", "git"]).optional(),
+  acceptanceCriteria: z.array(z.string().trim().min(1)).min(1).optional(),
+  maximumReviewCycles: z.number().int().positive().optional(),
+  condition: conditionDefinitionSchema.optional(),
+  graphRevisionCreated: z.number().int().positive(),
+  graphRevisionUpdated: z.number().int().positive()
+}).strict().superRefine((node, context) => {
+  const assignable = ["agentClass", "estimate", "requiredCapabilities", "requestedPermissions", "workspace"];
+  if (node.kind === "condition") {
+    if (!node.condition) context.addIssue({ code: z.ZodIssueCode.custom, path: ["condition"], message: "Condition nodes require condition." });
+    for (const key of assignable) if (node[key] !== void 0) context.addIssue({ code: z.ZodIssueCode.custom, path: [key], message: `Condition nodes cannot define ${key}.` });
+  } else {
+    for (const key of assignable) if (node[key] === void 0) context.addIssue({ code: z.ZodIssueCode.custom, path: [key], message: `Assignable nodes require ${key}.` });
+    if (node.condition) context.addIssue({ code: z.ZodIssueCode.custom, path: ["condition"], message: "Assignable nodes cannot define condition." });
+  }
+  if (node.pairRole && !(node.workItemId && node.maximumReviewCycles)) context.addIssue({ code: z.ZodIssueCode.custom, message: "Actor and Reviewer nodes require workItemId and maximumReviewCycles." });
+  if (node.graphRevisionUpdated < node.graphRevisionCreated) context.addIssue({ code: z.ZodIssueCode.custom, path: ["graphRevisionUpdated"], message: "Updated revision cannot precede created revision." });
+});
+const executionEdgeSchema = z.object({
+  schemaVersion: z.literal("treeseed.execution-edge/v1"),
+  id: identifier,
+  teamId: identifier,
+  fromNodeId: identifier,
+  toNodeId: identifier,
+  provenance: z.enum(["profile-agent", "profile-event", "work-item", "review-pair", "governance"]),
+  sourceRef: exactEntityReferenceSchema.optional(),
+  graphRevisionCreated: z.number().int().positive(),
+  graphRevisionRemoved: z.number().int().positive().optional()
+}).strict().refine((edge) => edge.fromNodeId !== edge.toNodeId, { message: "Execution edges cannot be self-referential." });
+const graphChangeSetSchema = z.object({
+  added: uniqueIds,
+  changed: uniqueIds,
+  completed: uniqueIds,
+  blocked: uniqueIds,
+  stale: uniqueIds,
+  removedEdges: uniqueIds,
+  addedEdges: uniqueIds
+}).strict();
+const graphRevisionSchema = z.object({
+  schemaVersion: z.literal("treeseed.graph-revision/v1"),
+  teamId: identifier,
+  revision: z.number().int().positive(),
+  ruleRevision: z.number().int().positive(),
+  changedSourceRefs: z.array(exactEntityReferenceSchema).min(1),
+  graphDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+  changes: graphChangeSetSchema,
+  createdAt: z.string().datetime({ offset: true })
+}).strict();
+function validateExecutionGraph(nodes, edges) {
+  const diagnostics = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const [index, candidate] of nodes.entries()) {
+    const parsed = executionNodeSchema.safeParse(candidate);
+    if (!parsed.success) diagnostics.push(...parsed.error.issues.map((issue) => ({ code: `execution_node_${issue.code}`, path: `nodes.${index}.${issue.path.join(".")}`, message: issue.message })));
+    if (nodeIds.has(candidate.id)) diagnostics.push({ code: "execution_node_duplicate", path: `nodes.${index}.id`, message: `Node ${candidate.id} is duplicated.` });
+    nodeIds.add(candidate.id);
+  }
+  const activeEdges = edges.filter((edge) => edge.graphRevisionRemoved === void 0);
+  const edgeIds = /* @__PURE__ */ new Set();
+  for (const [index, candidate] of edges.entries()) {
+    const parsed = executionEdgeSchema.safeParse(candidate);
+    if (!parsed.success) diagnostics.push(...parsed.error.issues.map((issue) => ({ code: `execution_edge_${issue.code}`, path: `edges.${index}.${issue.path.join(".")}`, message: issue.message })));
+    if (!nodeIds.has(candidate.fromNodeId) || !nodeIds.has(candidate.toNodeId)) diagnostics.push({ code: "execution_edge_endpoint_missing", path: `edges.${index}`, message: "Both edge endpoints must exist." });
+    if (edgeIds.has(candidate.id)) diagnostics.push({ code: "execution_edge_duplicate", path: `edges.${index}.id`, message: `Edge ${candidate.id} is duplicated.` });
+    edgeIds.add(candidate.id);
+  }
+  const outgoing = new Map([...nodeIds].map((id) => [id, []]));
+  for (const edge of activeEdges) outgoing.get(edge.fromNodeId)?.push(edge.toNodeId);
+  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 ((outgoing.get(id) ?? []).some(cyclic)) return true;
+    visiting.delete(id);
+    visited.add(id);
+    return false;
+  };
+  if ([...nodeIds].some(cyclic)) diagnostics.push({ code: "execution_graph_cycle", path: "edges", message: "Execution graph must be acyclic." });
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+export {
+  conditionDefinitionSchema,
+  executionEdgeSchema,
+  executionNodeSchema,
+  graphChangeSetSchema,
+  graphRevisionSchema,
+  validateExecutionGraph
+};

package/dist/agent-capacity/validation/activity-profile.d.ts

@@ -1,4 +1,4 @@
-import { type AgentActivityProfile, type AgentActivityType } from '../../types/agents.js';
+import type { AgentActivityProfile, AgentActivityType } from '../../types/agents.js';
 export interface AgentActivityProfileDiagnostic {
     code: string;
     path: string;

package/dist/agent-capacity/validation/activity-profile.js

@@ -1,276 +1,7 @@
-import { AGENT_ACTIVITY_TYPES, AGENT_HANDLER_KINDS } from "../../types/agents.js";
-import { compileAgentAuthoritySnapshot } from "../authority/agent-authority-presets.js";
-const PROFILE_KEYS = /* @__PURE__ */ new Set(["activityType", "enabled", "handler", "prompt", "branchPolicy", "contextQueryRefs", "contextQuerySetRefs", "instructionTemplateRefs", "capabilityRequirements", "permissions", "authorityPresets", "artifactTriggers", "closeoutPolicy", "tools", "signals", "outputs", "planningIntent", "questionPolicy", "execution"]);
-const PROMPT_KEYS = /* @__PURE__ */ new Set(["system", "task", "templates"]);
-const TOOL_KEYS = /* @__PURE__ */ new Set(["allowed", "denied"]);
-const SIGNAL_KEYS = /* @__PURE__ */ new Set(["subscribesTo", "publishes"]);
-const SUBSCRIPTION_KEYS = /* @__PURE__ */ new Set(["contract", "groupScope", "filters", "cardinality", "producerPolicy", "quorum"]);
-const OUTPUT_KEYS = /* @__PURE__ */ new Set(["messageTypes", "modelMutations"]);
-const EXECUTION_KEYS = /* @__PURE__ */ new Set(["reasoningEffort", "maxRuntimeSeconds", "preparationSeconds", "closeoutSeconds", "closeoutWarningSeconds", "maxRetries", "verificationRequired", "maxTotalTokens", "warningTokens", "maxCostAmount", "costCurrency", "nativeLimits", "pricingGeneration", "enforcementConfidence", "allowedPaths", "forbiddenPaths"]);
-const CONTENT_ACCESS_KEYS = /* @__PURE__ */ new Set(["content", "commit", "repository", "network", "shell"]);
-const MODEL_PERMISSION_KEYS = /* @__PURE__ */ new Set(["operations", "filters"]);
-const QUESTION_KEYS = /* @__PURE__ */ new Set(["defaultAnswerPolicy", "blockExecutionWhenCreated"]);
-const PLANNING_INTENT_KEYS = /* @__PURE__ */ new Set(["objective", "proposalTypes", "artifactKind", "subjectModel", "subjectId", "includeWorkdayArtifacts", "stage", "stages", "requiresArtifactKinds"]);
-const PLANNING_STAGE_KEYS = /* @__PURE__ */ new Set(["stage", "promptTask", "signals"]);
-const QUESTION_POLICY_KEYS = /* @__PURE__ */ new Set(["kind", "teamId", "requiredRoles", "allowedRoles", "allowedAgentIds", "allowedAgentClasses", "allowedActivityProfiles", "teamMemberId", "projectId", "agentSlug"]);
-const BRANCH_KEYS = {
-  "read-only": /* @__PURE__ */ new Set(["kind", "base"]),
-  "main-planning-content": /* @__PURE__ */ new Set(["kind", "base"]),
-  "staging-content": /* @__PURE__ */ new Set(["kind", "base"]),
-  "assignment-feature": /* @__PURE__ */ new Set(["kind", "base", "target", "prefix", "branchNameTemplate", "worktree", "updateBaseBeforeRun", "mergeTargetBeforeSave"]),
-  "staging-release": /* @__PURE__ */ new Set(["kind", "base", "target"])
-};
-function record(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function strings(value) {
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.trim().length > 0) && new Set(value).size === value.length;
-}
-function exactRefs(value) {
-  return Array.isArray(value) && value.every((entry) => record(entry) && typeof entry.id === "string" && entry.id.trim() && Number.isInteger(entry.revision) && Number(entry.revision) > 0) && new Set(value.map((entry) => `${entry.id}@${entry.revision}`)).size === value.length;
-}
-function unknownKeys(value, allowed, path, add) {
-  for (const key of Object.keys(value)) if (!allowed.has(key)) add("agent_activity_unknown_field", `${path}.${key}`, `Unknown activity-profile field ${path}.${key}.`);
-}
+import { activityProfilesSchema, diagnosticsFromZod } from "./agent-definition-schema.js";
 function validateAgentActivityProfilesConfiguration(value) {
-  const diagnostics = [];
-  const add = (code, path, message) => diagnostics.push({ code, path, message });
-  if (!record(value)) return { ok: false, diagnostics: [{ code: "agent_activity_profiles_invalid", path: "activityProfiles", message: "activityProfiles must be an object." }] };
-  let enabled = 0;
-  for (const [activity, raw] of Object.entries(value)) {
-    const path = `activityProfiles.${activity}`;
-    if (!AGENT_ACTIVITY_TYPES.includes(activity)) {
-      add("agent_activity_type_invalid", path, `Unsupported activity type ${activity}.`);
-      continue;
-    }
-    if (!record(raw)) {
-      add("agent_activity_profile_invalid", path, `${path} must be an object.`);
-      continue;
-    }
-    unknownKeys(raw, PROFILE_KEYS, path, add);
-    if (raw.activityType !== void 0 && raw.activityType !== activity) add("agent_activity_type_mismatch", `${path}.activityType`, "activityType must match its activityProfiles key.");
-    if (typeof raw.enabled !== "boolean") add("agent_activity_enabled_invalid", `${path}.enabled`, "enabled must be boolean.");
-    else if (raw.enabled) enabled += 1;
-    if (typeof raw.handler !== "string" || !AGENT_HANDLER_KINDS.includes(raw.handler)) add("agent_activity_handler_invalid", `${path}.handler`, "handler must name a supported built-in handler.");
-    if (!record(raw.prompt)) add("agent_activity_prompt_invalid", `${path}.prompt`, "prompt must be an object.");
-    else {
-      unknownKeys(raw.prompt, PROMPT_KEYS, `${path}.prompt`, add);
-      if (typeof raw.prompt.system !== "string" || !raw.prompt.system.trim()) add("agent_activity_system_prompt_required", `${path}.prompt.system`, "prompt.system is required.");
-      if (raw.prompt.task !== void 0 && typeof raw.prompt.task !== "string") add("agent_activity_task_prompt_invalid", `${path}.prompt.task`, "prompt.task must be a string.");
-      if (raw.prompt.templates !== void 0 && (!record(raw.prompt.templates) || Object.values(raw.prompt.templates).some((entry) => typeof entry !== "string"))) add("agent_activity_templates_invalid", `${path}.prompt.templates`, "prompt.templates must map names to strings.");
-    }
-    validateBranch(raw.branchPolicy, `${path}.branchPolicy`, add);
-    validateStringLists(raw.tools, TOOL_KEYS, ["allowed"], `${path}.tools`, add);
-    validateSignals(raw.signals, `${path}.signals`, add);
-    validateStringLists(raw.outputs, OUTPUT_KEYS, ["messageTypes", "modelMutations"], `${path}.outputs`, add);
-    validatePlanningIntent(raw.planningIntent, `${path}.planningIntent`, add);
-    validateContentAccess(raw.permissions, `${path}.permissions`, add);
-    if (raw.authorityPresets !== void 0 && (!strings(raw.authorityPresets) || raw.authorityPresets.some((preset) => !["messaging", "direction", "influence", "estimation", "plan-contribution", "source-execution", "review-authority", "reporting"].includes(preset)))) add("agent_activity_authority_presets_invalid", `${path}.authorityPresets`, "authorityPresets must contain supported unique preset ids.");
-    for (const key of ["contextQueryRefs", "contextQuerySetRefs", "instructionTemplateRefs"]) if (raw[key] !== void 0 && !exactRefs(raw[key])) add("agent_activity_revision_refs_invalid", `${path}.${key}`, `${path}.${key} must contain unique exact id and revision references.`);
-    validateCapabilityRequirements(raw.capabilityRequirements, `${path}.capabilityRequirements`, add);
-    validateArtifactTriggers(raw.artifactTriggers, `${path}.artifactTriggers`, add);
-    validateCloseoutPolicy(raw.closeoutPolicy, `${path}.closeoutPolicy`, add);
-    validateQuestionPolicy(raw.questionPolicy, `${path}.questionPolicy`, add);
-    validateExecution(raw.execution, `${path}.execution`, add);
-    if (typeof raw.enabled === "boolean" && typeof raw.handler === "string" && record(raw.tools) && record(raw.outputs) && record(raw.branchPolicy)) {
-      for (const message of compileAgentAuthoritySnapshot(activity, raw).diagnostics) {
-        add("agent_activity_authority_widening_forbidden", path, message);
-      }
-    }
-  }
-  if (enabled === 0) add("agent_activity_profile_enabled_required", "activityProfiles", "At least one activity profile must be enabled.");
-  return { ok: diagnostics.length === 0, diagnostics };
-}
-function validateSignals(value, path, add) {
-  if (value === void 0) return;
-  if (!record(value)) {
-    add("agent_activity_signals_invalid", path, "signals must be an object.");
-    return;
-  }
-  unknownKeys(value, SIGNAL_KEYS, path, add);
-  if (value.publishes !== void 0 && !strings(value.publishes)) add("agent_activity_signal_publications_invalid", `${path}.publishes`, "publishes must contain unique signal contract IDs.");
-  if (value.subscribesTo === void 0) return;
-  if (!Array.isArray(value.subscribesTo)) {
-    add("agent_activity_signal_subscriptions_invalid", `${path}.subscribesTo`, "subscribesTo must be an array.");
-    return;
-  }
-  value.subscribesTo.forEach((candidate, index) => {
-    const itemPath = `${path}.subscribesTo[${index}]`;
-    if (!record(candidate)) {
-      add("agent_activity_signal_subscription_invalid", itemPath, "Signal subscription must be an object.");
-      return;
-    }
-    unknownKeys(candidate, SUBSCRIPTION_KEYS, itemPath, add);
-    if (typeof candidate.contract !== "string" || !candidate.contract.trim()) add("agent_activity_signal_contract_required", `${itemPath}.contract`, "Signal subscription contract is required.");
-    if (candidate.filters !== void 0 && !record(candidate.filters)) add("agent_activity_signal_filters_invalid", `${itemPath}.filters`, "Signal filters must be an object.");
-    if (candidate.groupScope !== void 0) validateGroupScope(candidate.groupScope, `${itemPath}.groupScope`, add);
-    if (candidate.cardinality !== void 0 && !["single", "each"].includes(String(candidate.cardinality))) add("agent_activity_signal_cardinality_invalid", `${itemPath}.cardinality`, "cardinality must be single or each.");
-    if (candidate.producerPolicy !== void 0 && !["any", "all", "quorum"].includes(String(candidate.producerPolicy))) add("agent_activity_producer_policy_invalid", `${itemPath}.producerPolicy`, "producerPolicy must be any, all, or quorum.");
-    if (candidate.producerPolicy === "quorum" && (!Number.isInteger(candidate.quorum) || Number(candidate.quorum) < 1)) add("agent_activity_signal_quorum_invalid", `${itemPath}.quorum`, "quorum must be a positive integer.");
-  });
-}
-function validateGroupScope(value, path, add) {
-  if (!record(value) || !["member-groups", "specific-groups", "project"].includes(String(value.mode))) {
-    add("agent_activity_group_scope_invalid", path, "groupScope.mode must be member-groups, specific-groups, or project.");
-    return;
-  }
-  if (value.mode === "project" && (typeof value.projectId !== "string" || !value.projectId.trim())) add("agent_activity_group_scope_project_required", `${path}.projectId`, "Project-scoped subscriptions require projectId.");
-  if (value.mode === "specific-groups" && (!Array.isArray(value.groupRefs) || value.groupRefs.length === 0 || value.groupRefs.some((candidate) => !record(candidate) || typeof candidate.projectId !== "string" || typeof candidate.groupId !== "string"))) add("agent_activity_group_scope_refs_required", `${path}.groupRefs`, "Specific group scopes require projectId and groupId references.");
-}
-function validatePlanningIntent(value, path, add) {
-  if (value === void 0) return;
-  if (!record(value)) {
-    add("agent_activity_planning_intent_invalid", path, "planningIntent must be an object.");
-    return;
-  }
-  unknownKeys(value, PLANNING_INTENT_KEYS, path, add);
-  for (const key of ["objective", "artifactKind", "subjectModel"]) {
-    if (value[key] !== void 0 && (typeof value[key] !== "string" || !value[key].trim())) add("agent_activity_planning_intent_text_invalid", `${path}.${key}`, `${path}.${key} must be a non-empty string.`);
-  }
-  if (value.subjectId !== void 0 && value.subjectId !== null && (typeof value.subjectId !== "string" || !value.subjectId.trim())) add("agent_activity_planning_intent_text_invalid", `${path}.subjectId`, `${path}.subjectId must be a non-empty string or null.`);
-  if (value.includeWorkdayArtifacts !== void 0 && typeof value.includeWorkdayArtifacts !== "boolean") add("agent_activity_planning_intent_boolean_invalid", `${path}.includeWorkdayArtifacts`, `${path}.includeWorkdayArtifacts must be boolean.`);
-  const stages = ["discovery", "synthesis", "deliberation", "evaluation", "revision", "closeout"];
-  if (value.stage !== void 0 && !stages.includes(String(value.stage))) add("agent_activity_planning_stage_invalid", `${path}.stage`, `${path}.stage is unsupported.`);
-  if (value.stages !== void 0) {
-    if (!Array.isArray(value.stages) || value.stages.length === 0) add("agent_activity_planning_stages_invalid", `${path}.stages`, "stages must be a non-empty array.");
-    else value.stages.forEach((candidate, index) => {
-      const stagePath = `${path}.stages[${index}]`;
-      if (!record(candidate)) {
-        add("agent_activity_planning_stage_invalid", stagePath, "Planning stage must be an object.");
-        return;
-      }
-      unknownKeys(candidate, PLANNING_STAGE_KEYS, stagePath, add);
-      if (!stages.includes(String(candidate.stage))) add("agent_activity_planning_stage_invalid", `${stagePath}.stage`, "Planning stage is unsupported.");
-      if (candidate.promptTask !== void 0 && (typeof candidate.promptTask !== "string" || !candidate.promptTask.trim())) add("agent_activity_planning_stage_prompt_invalid", `${stagePath}.promptTask`, "promptTask must be non-empty.");
-      validateSignals(candidate.signals, `${stagePath}.signals`, add);
-    });
-  }
-  if (value.requiresArtifactKinds !== void 0 && !strings(value.requiresArtifactKinds)) add("agent_activity_string_list_invalid", `${path}.requiresArtifactKinds`, `${path}.requiresArtifactKinds must contain unique non-empty strings.`);
-  if (value.proposalTypes !== void 0 && !strings(value.proposalTypes)) add("agent_activity_string_list_invalid", `${path}.proposalTypes`, `${path}.proposalTypes must contain unique non-empty strings.`);
-}
-function validateStringLists(value, keys, required, path, add) {
-  if (!record(value)) {
-    add("agent_activity_policy_invalid", path, `${path} must be an object.`);
-    return;
-  }
-  unknownKeys(value, keys, path, add);
-  for (const key of required) if (!strings(value[key])) add("agent_activity_string_list_invalid", `${path}.${key}`, `${path}.${key} must contain unique non-empty strings.`);
-  for (const key of keys) if (!["producerPolicy", "fanout"].includes(key) && value[key] !== void 0 && !strings(value[key])) add("agent_activity_string_list_invalid", `${path}.${key}`, `${path}.${key} must contain unique non-empty strings.`);
-}
-function validateBranch(value, path, add) {
-  if (!record(value) || typeof value.kind !== "string" || !BRANCH_KEYS[value.kind]) {
-    add("agent_activity_branch_policy_invalid", path, "branchPolicy.kind is invalid.");
-    return;
-  }
-  unknownKeys(value, BRANCH_KEYS[value.kind], path, add);
-  const expected = value.kind === "read-only" ? ["main", "staging"] : value.kind === "main-planning-content" ? ["main"] : ["staging"];
-  if (!expected.includes(String(value.base))) add("agent_activity_branch_base_invalid", `${path}.base`, `branchPolicy.base must be ${expected.join(" or ")}.`);
-  if (value.kind === "assignment-feature" && value.target !== "staging") add("agent_activity_branch_target_invalid", `${path}.target`, "assignment-feature target must be staging.");
-  if (value.kind === "staging-release" && value.target !== "main") add("agent_activity_branch_target_invalid", `${path}.target`, "staging-release target must be main.");
-}
-function validateContentAccess(value, path, add) {
-  if (value === void 0) return;
-  if (!record(value)) {
-    add("agent_activity_permissions_invalid", path, "permissions must be an object.");
-    return;
-  }
-  unknownKeys(value, CONTENT_ACCESS_KEYS, path, add);
-  if (value.content !== void 0) {
-    if (!record(value.content)) add("agent_activity_content_matrix_invalid", `${path}.content`, "content permissions must map model names to operation/filter policies.");
-    else for (const [model, permission] of Object.entries(value.content)) {
-      const modelPath = `${path}.content.${model}`;
-      if (!model.trim() || !record(permission)) {
-        add("agent_activity_model_permission_invalid", modelPath, "Each model permission must be an object.");
-        continue;
-      }
-      unknownKeys(permission, MODEL_PERMISSION_KEYS, modelPath, add);
-      if (!strings(permission.operations) || permission.operations.length === 0) add("agent_activity_model_operations_invalid", `${modelPath}.operations`, "Model operations must contain unique non-empty values.");
-      if (permission.filters !== void 0 && !record(permission.filters)) add("agent_activity_model_filters_invalid", `${modelPath}.filters`, "Model filters must be an object.");
-    }
-  }
-  if (value.commit !== void 0 && (!record(value.commit) || typeof value.commit.allowed !== "boolean" || Object.keys(value.commit).some((key) => key !== "allowed"))) add("agent_activity_commit_policy_invalid", `${path}.commit`, "commit must contain only a boolean allowed field.");
-  for (const key of ["repository", "network", "shell"]) if (value[key] !== void 0 && !record(value[key])) add("agent_activity_permissions_invalid", `${path}.${key}`, `${key} permissions must be an object.`);
-}
-function validateArtifactTriggers(value, path, add) {
-  if (value === void 0) return;
-  if (!Array.isArray(value)) {
-    add("agent_activity_artifact_triggers_invalid", path, "artifactTriggers must be an array.");
-    return;
-  }
-  value.forEach((candidate, index) => {
-    const itemPath = `${path}[${index}]`;
-    if (!record(candidate)) {
-      add("agent_activity_artifact_trigger_invalid", itemPath, "Artifact trigger must be an object.");
-      return;
-    }
-    unknownKeys(candidate, /* @__PURE__ */ new Set(["event", "artifactKind", "model", "required"]), itemPath, add);
-    for (const key of ["event", "artifactKind"]) if (typeof candidate[key] !== "string" || !candidate[key].trim()) add("agent_activity_artifact_trigger_invalid", `${itemPath}.${key}`, `${key} is required.`);
-  });
-}
-function validateCloseoutPolicy(value, path, add) {
-  if (value === void 0) return;
-  if (!record(value)) {
-    add("agent_activity_closeout_policy_invalid", path, "closeoutPolicy must be an object.");
-    return;
-  }
-  unknownKeys(value, /* @__PURE__ */ new Set(["warningSeconds", "summaryRequired", "requiredArtifactKinds", "blockOnOpenQuestions"]), path, add);
-  if (value.warningSeconds !== void 0 && (!Number.isInteger(value.warningSeconds) || Number(value.warningSeconds) < 1)) add("agent_activity_closeout_warning_invalid", `${path}.warningSeconds`, "warningSeconds must be positive.");
-  if (value.requiredArtifactKinds !== void 0 && !strings(value.requiredArtifactKinds)) add("agent_activity_string_list_invalid", `${path}.requiredArtifactKinds`, "requiredArtifactKinds must contain unique non-empty strings.");
-}
-function validateCapabilityRequirements(value, path, add) {
-  if (value === void 0) {
-    add("agent_activity_capability_requirements_required", path, "capabilityRequirements is required.");
-    return;
-  }
-  if (!Array.isArray(value) || value.length === 0) {
-    add("agent_activity_capability_requirements_required", path, "capabilityRequirements must be a non-empty array.");
-    return;
-  }
-  value.forEach((candidate, index) => {
-    const itemPath = `${path}[${index}]`;
-    if (!record(candidate)) {
-      add("agent_activity_capability_requirement_invalid", itemPath, "Capability requirement must be an object.");
-      return;
-    }
-    unknownKeys(candidate, /* @__PURE__ */ new Set(["capabilityId", "versionRange", "requirement", "alternativeGroup", "requiredFeatures", "configuration"]), itemPath, add);
-    if (typeof candidate.capabilityId !== "string" || !/^(?:treeseed\.|provider\.)/u.test(candidate.capabilityId)) add("agent_activity_capability_id_invalid", `${itemPath}.capabilityId`, "capabilityId must use a TreeSeed or provider namespace.");
-    if (typeof candidate.versionRange !== "string" || !candidate.versionRange.trim()) add("agent_activity_capability_version_invalid", `${itemPath}.versionRange`, "versionRange is required.");
-    if (!["required", "preferred"].includes(String(candidate.requirement))) add("agent_activity_capability_requirement_invalid", `${itemPath}.requirement`, "requirement must be required or preferred.");
-    if (candidate.requiredFeatures !== void 0 && !strings(candidate.requiredFeatures)) add("agent_activity_capability_features_invalid", `${itemPath}.requiredFeatures`, "requiredFeatures must contain unique values.");
-    if (candidate.configuration !== void 0 && !record(candidate.configuration)) add("agent_activity_capability_configuration_invalid", `${itemPath}.configuration`, "configuration must be an object.");
-  });
-}
-function validateQuestionPolicy(value, path, add) {
-  if (value === void 0) return;
-  if (!record(value)) {
-    add("agent_activity_question_policy_invalid", path, "questionPolicy must be an object.");
-    return;
-  }
-  unknownKeys(value, QUESTION_KEYS, path, add);
-  if (value.blockExecutionWhenCreated !== void 0 && typeof value.blockExecutionWhenCreated !== "boolean") add("agent_activity_question_block_invalid", `${path}.blockExecutionWhenCreated`, "blockExecutionWhenCreated must be boolean.");
-  if (value.defaultAnswerPolicy !== void 0) {
-    if (!record(value.defaultAnswerPolicy)) add("agent_activity_answer_policy_invalid", `${path}.defaultAnswerPolicy`, "defaultAnswerPolicy must be an object.");
-    else {
-      unknownKeys(value.defaultAnswerPolicy, QUESTION_POLICY_KEYS, `${path}.defaultAnswerPolicy`, add);
-      if (!["team-human", "human-or-agent", "specific-human", "specific-agent"].includes(String(value.defaultAnswerPolicy.kind))) add("agent_activity_answer_policy_kind_invalid", `${path}.defaultAnswerPolicy.kind`, "Unknown answer policy kind.");
-    }
-  }
-}
-function validateExecution(value, path, add) {
-  if (value === void 0) return;
-  if (!record(value)) {
-    add("agent_activity_execution_invalid", path, "execution must be an object.");
-    return;
-  }
-  unknownKeys(value, EXECUTION_KEYS, path, add);
-  for (const key of ["allowedPaths", "forbiddenPaths"]) if (value[key] !== void 0 && !strings(value[key])) add("agent_activity_string_list_invalid", `${path}.${key}`, `${path}.${key} must contain unique non-empty strings.`);
-  if (value.reasoningEffort !== void 0 && !["minimal", "low", "medium", "high", "xhigh"].includes(String(value.reasoningEffort))) add("agent_activity_reasoning_effort_invalid", `${path}.reasoningEffort`, "reasoningEffort must be minimal, low, medium, high, or xhigh.");
-  if (value.maxRuntimeSeconds !== void 0 && (!Number.isInteger(value.maxRuntimeSeconds) || Number(value.maxRuntimeSeconds) < 1)) add("agent_activity_runtime_invalid", `${path}.maxRuntimeSeconds`, "maxRuntimeSeconds must be a positive integer.");
-  if (value.closeoutWarningSeconds !== void 0 && (!Number.isInteger(value.closeoutWarningSeconds) || Number(value.closeoutWarningSeconds) < 1)) add("agent_activity_closeout_warning_invalid", `${path}.closeoutWarningSeconds`, "closeoutWarningSeconds must be a positive integer.");
-  if (value.preparationSeconds !== void 0 && (!Number.isInteger(value.preparationSeconds) || Number(value.preparationSeconds) < 1)) add("agent_activity_preparation_duration_invalid", `${path}.preparationSeconds`, "preparationSeconds must be a positive integer.");
-  if (value.closeoutSeconds !== void 0 && (!Number.isInteger(value.closeoutSeconds) || Number(value.closeoutSeconds) < 1)) add("agent_activity_closeout_duration_invalid", `${path}.closeoutSeconds`, "closeoutSeconds must be a positive integer.");
-  if (value.maxRetries !== void 0 && (!Number.isInteger(value.maxRetries) || Number(value.maxRetries) < 0)) add("agent_activity_retries_invalid", `${path}.maxRetries`, "maxRetries must be a non-negative integer.");
-  if (value.verificationRequired !== void 0 && typeof value.verificationRequired !== "boolean") add("agent_activity_verification_invalid", `${path}.verificationRequired`, "verificationRequired must be boolean.");
+  const parsed = activityProfilesSchema.safeParse(value);
+  return parsed.success ? { ok: true, diagnostics: [] } : { ok: false, diagnostics: diagnosticsFromZod(parsed.error, "activityProfiles") };
 }
 export {
   validateAgentActivityProfilesConfiguration