@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/agent-capacity/validation/agent-definition-schema.js

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { AGENT_ACTIVITY_TYPES, AGENT_HANDLER_KINDS } from "../../types/agents.js";
+import { validateAgentActivityProfilesConfiguration } from "./activity-profile.js";
+const nonEmpty = z.string().trim().min(1);
+const stringList = z.array(nonEmpty).superRefine((items, context) => {
+  if (new Set(items).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
+});
+const nonEmptyStringList = z.array(nonEmpty).min(1).superRefine((items, context) => {
+  if (new Set(items).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Values must be unique." });
+});
+const exactRevisionRefSchema = z.object({ id: nonEmpty, revision: z.number().int().positive() }).strict();
+const exactRevisionRefList = z.array(exactRevisionRefSchema).superRefine((items, context) => {
+  if (new Set(items.map((item) => `${item.id}@${item.revision}`)).size !== items.length) context.addIssue({ code: z.ZodIssueCode.custom, message: "Exact revision references must be unique." });
+});
+const promptSchema = z.object({ system: nonEmpty, task: z.string().optional(), templates: z.record(z.string()).optional() }).strict();
+const toolPolicySchema = z.object({ allowed: stringList, denied: stringList.optional() }).strict();
+const modelPermissionSchema = z.object({ operations: nonEmptyStringList, filters: z.record(z.unknown()).optional() }).strict();
+const permissionsSchema = z.object({
+  content: z.record(modelPermissionSchema).optional(),
+  commit: z.object({ allowed: z.boolean() }).strict().optional(),
+  repository: z.object({ readPaths: stringList.optional(), writePaths: stringList.optional(), allowCodeMutation: z.boolean().optional() }).strict().optional(),
+  network: z.object({ allowWeb: z.boolean().optional(), allowedDomains: stringList.optional() }).strict().optional(),
+  shell: z.object({ allowCommands: z.boolean().optional(), allowedCommands: stringList.optional(), deniedCommands: stringList.optional() }).strict().optional()
+}).strict();
+const artifactTriggerSchema = z.object({
+  event: nonEmpty,
+  artifactKind: nonEmpty,
+  model: nonEmpty.optional(),
+  required: z.boolean().optional()
+}).strict();
+const closeoutPolicySchema = z.object({
+  warningSeconds: z.number().int().positive().optional(),
+  summaryRequired: z.boolean().optional(),
+  requiredArtifactKinds: stringList.optional(),
+  blockOnOpenQuestions: z.boolean().optional()
+}).strict();
+const providerOverridesSchema = z.object({
+  requiredCapabilities: stringList.optional(),
+  disallowedProviderIds: stringList.optional(),
+  promptRef: nonEmpty.optional(),
+  instructionTemplateRefs: exactRevisionRefList.optional(),
+  maxRuntimeSeconds: z.number().int().positive().optional(),
+  maxTotalTokens: z.number().int().positive().optional(),
+  maxCostAmount: z.number().nonnegative().optional()
+}).strict();
+const branchPolicySchema = z.object({
+  kind: z.enum(["read-only", "main-planning-content", "staging-content", "assignment-feature", "staging-release"]),
+  base: z.enum(["main", "staging"]),
+  target: z.enum(["main", "staging"]).optional(),
+  prefix: z.string().optional(),
+  branchNameTemplate: z.string().optional(),
+  worktree: z.string().optional(),
+  updateBaseBeforeRun: z.boolean().optional(),
+  mergeTargetBeforeSave: z.boolean().optional()
+}).strict();
+const signalPolicySchema = z.object({
+  subscribesTo: z.array(z.object({
+    contract: nonEmpty,
+    groupScope: z.object({ mode: nonEmpty, projectId: nonEmpty.optional(), groupRefs: z.array(z.object({ projectId: nonEmpty, groupId: nonEmpty }).strict()).optional() }).strict().optional(),
+    filters: z.record(z.unknown()).optional(),
+    cardinality: z.enum(["single", "each"]).optional(),
+    producerPolicy: z.enum(["any", "all", "quorum"]).optional(),
+    quorum: z.number().int().positive().optional()
+  }).strict()).optional(),
+  publishes: stringList.optional()
+}).strict();
+const planningSignalsSchema = signalPolicySchema.optional();
+const planningIntentSchema = z.object({
+  objective: nonEmpty.optional(),
+  proposalTypes: stringList.optional(),
+  artifactKind: nonEmpty.optional(),
+  subjectModel: nonEmpty.optional(),
+  subjectId: nonEmpty.nullable().optional(),
+  includeWorkdayArtifacts: z.boolean().optional(),
+  stage: z.enum(["discovery", "synthesis", "deliberation", "evaluation", "revision", "closeout"]).optional(),
+  stages: z.array(z.object({
+    stage: z.enum(["discovery", "synthesis", "deliberation", "evaluation", "revision", "closeout"]),
+    promptTask: nonEmpty.optional(),
+    signals: planningSignalsSchema
+  }).strict()).min(1).optional(),
+  requiresArtifactKinds: stringList.optional()
+}).strict();
+const answerPolicySchema = z.object({
+  kind: z.enum(["team-human", "human-or-agent", "specific-human", "specific-agent"]),
+  teamId: nonEmpty.optional(),
+  requiredRoles: stringList.optional(),
+  allowedRoles: stringList.optional(),
+  allowedAgentIds: stringList.optional(),
+  allowedAgentClasses: stringList.optional(),
+  allowedActivityProfiles: stringList.optional(),
+  teamMemberId: nonEmpty.optional(),
+  projectId: nonEmpty.optional(),
+  agentSlug: nonEmpty.optional()
+}).strict();
+const executionSchema = z.object({
+  requiredCapabilities: stringList.optional(),
+  maxRuntimeSeconds: z.number().int().positive().optional(),
+  closeoutWarningSeconds: z.number().int().positive().optional(),
+  preparationSeconds: z.number().int().positive().optional(),
+  closeoutSeconds: z.number().int().positive().optional(),
+  maxRetries: z.number().int().nonnegative().optional(),
+  verificationRequired: z.boolean().optional(),
+  maxTotalTokens: z.number().int().positive().optional(),
+  warningTokens: z.number().int().positive().optional(),
+  maxCostAmount: z.number().nonnegative().optional(),
+  costCurrency: z.string().length(3).optional(),
+  nativeLimits: z.array(z.object({ unit: nonEmpty, amount: z.number().nonnegative(), enforceable: z.boolean().optional() }).strict()).optional(),
+  pricingGeneration: z.string().optional(),
+  enforcementConfidence: z.enum(["exact", "bounded", "estimated", "opaque"]).optional(),
+  allowedPaths: stringList.optional(),
+  forbiddenPaths: stringList.optional()
+}).strict();
+const activityProfileSchema = z.object({
+  activityType: z.enum(AGENT_ACTIVITY_TYPES).optional(),
+  enabled: z.boolean(),
+  handler: z.enum(AGENT_HANDLER_KINDS),
+  prompt: promptSchema,
+  branchPolicy: branchPolicySchema,
+  contextQueryRefs: exactRevisionRefList.optional(),
+  contextQuerySetRefs: exactRevisionRefList.optional(),
+  instructionTemplateRefs: exactRevisionRefList.optional(),
+  permissions: permissionsSchema.optional(),
+  artifactTriggers: z.array(artifactTriggerSchema).optional(),
+  closeoutPolicy: closeoutPolicySchema.optional(),
+  providerOverrides: providerOverridesSchema.optional(),
+  tools: toolPolicySchema,
+  signals: signalPolicySchema.optional(),
+  outputs: z.object({ messageTypes: stringList, modelMutations: stringList }).strict(),
+  planningIntent: planningIntentSchema.optional(),
+  questionPolicy: z.object({ blockExecutionWhenCreated: z.boolean().optional(), defaultAnswerPolicy: answerPolicySchema.optional() }).strict().optional(),
+  execution: executionSchema.optional()
+}).strict().superRefine((profile, context) => {
+  const overrides = profile.providerOverrides;
+  if (!overrides) return;
+  for (const key of ["maxRuntimeSeconds", "maxTotalTokens", "maxCostAmount"]) {
+    if (overrides[key] !== void 0 && (profile.execution?.[key] === void 0 || overrides[key] > profile.execution[key])) {
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["providerOverrides", key], message: `${key} must narrow an explicit profile execution limit.` });
+    }
+  }
+  if (overrides.promptRef && !Object.hasOwn(profile.prompt.templates ?? {}, overrides.promptRef)) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["providerOverrides", "promptRef"], message: "Provider promptRef must select a declared profile prompt template." });
+  }
+});
+const agentDefinitionSchema = z.object({
+  id: nonEmpty,
+  slug: nonEmpty,
+  title: nonEmpty,
+  name: nonEmpty,
+  description: nonEmpty,
+  summary: nonEmpty,
+  agentClass: nonEmpty,
+  projectAgentClassId: nonEmpty,
+  projectAgentClassSlug: nonEmpty,
+  template: z.string().optional(),
+  enabled: z.boolean(),
+  designMaturity: z.enum(["draft", "validated", "simulated", "proven"]).optional(),
+  runtimeStatus: z.enum(["active", "experimental", "dormant"]).optional(),
+  groupIds: nonEmptyStringList,
+  topicIds: stringList.optional(),
+  contextQueryRefs: exactRevisionRefList.optional(),
+  contextQuerySetRefs: exactRevisionRefList.optional(),
+  instructionTemplateRefs: exactRevisionRefList.optional(),
+  identity: z.object({ purpose: nonEmpty, responsibilities: stringList, durableInstructions: nonEmpty }).passthrough(),
+  capabilities: z.array(z.union([nonEmpty, z.object({ id: nonEmpty }).passthrough()])).optional(),
+  activityProfiles: z.record(activityProfileSchema)
+}).passthrough().superRefine((agent, context) => {
+  const raw = agent;
+  for (const legacy of ["primaryGroupId", "permissionPolicy", "contentAccess"]) if (legacy in raw) context.addIssue({ code: z.ZodIssueCode.custom, path: [legacy], message: `${legacy} is not part of the canonical agent contract.` });
+  for (const [profileName, profile] of Object.entries(agent.activityProfiles)) {
+    const key = (ref) => `${ref.id}@${ref.revision}`;
+    const allowed = new Set([...agent.instructionTemplateRefs ?? [], ...profile.instructionTemplateRefs ?? []].map(key));
+    if (profile.providerOverrides?.instructionTemplateRefs?.some((ref) => !allowed.has(key(ref)))) context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["activityProfiles", profileName, "providerOverrides", "instructionTemplateRefs"],
+      message: "Provider instruction templates must narrow common or profile instruction templates."
+    });
+  }
+});
+function issuePath(path) {
+  return path.reduce((current, segment) => typeof segment === "number" ? `${current}[${segment}]` : current ? `${current}.${segment}` : segment, "");
+}
+function validateAgentDefinitionModel(value) {
+  const parsed = agentDefinitionSchema.safeParse(value);
+  const diagnostics = parsed.success ? [] : parsed.error.issues.map((issue) => ({
+    code: `agent_zod_${issue.code}`,
+    path: issuePath(issue.path),
+    message: issue.message
+  }));
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    diagnostics.push(...validateAgentActivityProfilesConfiguration(value.activityProfiles).diagnostics);
+  }
+  const unique = new Map(diagnostics.map((diagnostic) => [`${diagnostic.code}:${diagnostic.path}:${diagnostic.message}`, diagnostic]));
+  return { ok: unique.size === 0, diagnostics: [...unique.values()], data: parsed.success ? parsed.data : null };
+}
+export {
+  agentDefinitionSchema,
+  validateAgentDefinitionModel
+};

package/dist/agent-capacity/validation/agent-lab-forensics-schema.d.ts

@@ -0,0 +1,234 @@
+import { z } from 'zod';
+import type { AgentActivityEvent } from '../contracts/capacity/workdays/workday-records.js';
+export declare const agentActivityEventSchema: z.ZodType<AgentActivityEvent>;
+export declare const agentActivityQuerySchema: z.ZodObject<{
+    after: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    agent: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    agentClass: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    type: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    severity: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+}, "strict", z.ZodTypeAny, {
+    limit: number;
+    after: number;
+    type?: string | string[] | undefined;
+    agent?: string | string[] | undefined;
+    agentClass?: string | string[] | undefined;
+    severity?: string | string[] | undefined;
+}, {
+    type?: string | string[] | undefined;
+    agent?: string | string[] | undefined;
+    limit?: number | undefined;
+    agentClass?: string | string[] | undefined;
+    severity?: string | string[] | undefined;
+    after?: number | undefined;
+}>;
+export declare const agentActivityPageSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodType<AgentActivityEvent, z.ZodTypeDef, AgentActivityEvent>, "many">;
+    cursor: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    items: AgentActivityEvent[];
+    cursor: number;
+}, {
+    items: AgentActivityEvent[];
+    cursor: number;
+}>;
+export declare const agentReplayRequestSchema: z.ZodEffects<z.ZodObject<{
+    workdayId: z.ZodOptional<z.ZodString>;
+    at: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    includeDiagnostics: z.ZodDefault<z.ZodBoolean>;
+    includePayloads: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    includeDiagnostics: boolean;
+    includePayloads: boolean;
+    at?: string | undefined;
+    cursor?: string | null | undefined;
+    workdayId?: string | undefined;
+}, {
+    at?: string | undefined;
+    cursor?: string | null | undefined;
+    workdayId?: string | undefined;
+    includeDiagnostics?: boolean | undefined;
+    includePayloads?: boolean | undefined;
+}>, {
+    includeDiagnostics: boolean;
+    includePayloads: boolean;
+    at?: string | undefined;
+    cursor?: string | null | undefined;
+    workdayId?: string | undefined;
+}, {
+    at?: string | undefined;
+    cursor?: string | null | undefined;
+    workdayId?: string | undefined;
+    includeDiagnostics?: boolean | undefined;
+    includePayloads?: boolean | undefined;
+}>;
+export declare const agentTranscriptPayloadSchema: z.ZodObject<{
+    executionRunId: z.ZodString;
+    redactionStatus: z.ZodEnum<["sanitized", "partially-redacted", "withheld"]>;
+    entries: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    page: z.ZodObject<{
+        limit: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }, {
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    entries: Record<string, unknown>[];
+    page: {
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+    executionRunId: string;
+    redactionStatus: "sanitized" | "partially-redacted" | "withheld";
+}, {
+    entries: Record<string, unknown>[];
+    page: {
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+    executionRunId: string;
+    redactionStatus: "sanitized" | "partially-redacted" | "withheld";
+}>;
+export declare const agentForensicPayloadSchema: z.ZodObject<{
+    contract: z.ZodLiteral<"treeseed.agent-forensic-payload/v1">;
+    activity: z.ZodType<AgentActivityEvent, z.ZodTypeDef, AgentActivityEvent>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    transcript: z.ZodOptional<z.ZodObject<{
+        executionRunId: z.ZodString;
+        redactionStatus: z.ZodEnum<["sanitized", "partially-redacted", "withheld"]>;
+        entries: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        page: z.ZodObject<{
+            limit: z.ZodNumber;
+            hasMore: z.ZodBoolean;
+            nextCursor: z.ZodNullable<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            limit: number;
+            hasMore: boolean;
+            nextCursor: string | null;
+        }, {
+            limit: number;
+            hasMore: boolean;
+            nextCursor: string | null;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        entries: Record<string, unknown>[];
+        page: {
+            limit: number;
+            hasMore: boolean;
+            nextCursor: string | null;
+        };
+        executionRunId: string;
+        redactionStatus: "sanitized" | "partially-redacted" | "withheld";
+    }, {
+        entries: Record<string, unknown>[];
+        page: {
+            limit: number;
+            hasMore: boolean;
+            nextCursor: string | null;
+        };
+        executionRunId: string;
+        redactionStatus: "sanitized" | "partially-redacted" | "withheld";
+    }>>;
+    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        path: z.ZodString;
+        message: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "error"]>;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        path: string;
+        message: string;
+        severity: "error" | "warning" | "info";
+    }, {
+        code: string;
+        path: string;
+        message: string;
+        severity: "error" | "warning" | "info";
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    contract: "treeseed.agent-forensic-payload/v1";
+    activity: AgentActivityEvent;
+    diagnostics: {
+        code: string;
+        path: string;
+        message: string;
+        severity: "error" | "warning" | "info";
+    }[];
+    payload?: Record<string, unknown> | undefined;
+    transcript?: {
+        entries: Record<string, unknown>[];
+        page: {
+            limit: number;
+            hasMore: boolean;
+            nextCursor: string | null;
+        };
+        executionRunId: string;
+        redactionStatus: "sanitized" | "partially-redacted" | "withheld";
+    } | undefined;
+}, {
+    contract: "treeseed.agent-forensic-payload/v1";
+    activity: AgentActivityEvent;
+    payload?: Record<string, unknown> | undefined;
+    transcript?: {
+        entries: Record<string, unknown>[];
+        page: {
+            limit: number;
+            hasMore: boolean;
+            nextCursor: string | null;
+        };
+        executionRunId: string;
+        redactionStatus: "sanitized" | "partially-redacted" | "withheld";
+    } | undefined;
+    diagnostics?: {
+        code: string;
+        path: string;
+        message: string;
+        severity: "error" | "warning" | "info";
+    }[] | undefined;
+}>;
+export type AgentActivityQuery = z.infer<typeof agentActivityQuerySchema>;
+export type AgentActivityPage = z.infer<typeof agentActivityPageSchema>;
+export type AgentReplayRequest = z.infer<typeof agentReplayRequestSchema>;
+export type AgentTranscriptPayload = z.infer<typeof agentTranscriptPayloadSchema>;
+export type AgentForensicPayload = z.infer<typeof agentForensicPayloadSchema>;
+export declare function parseAgentActivityEvent(value: unknown): AgentActivityEvent;
+export declare function parseAgentActivityQuery(value: unknown): {
+    limit: number;
+    after: number;
+    type?: string | string[] | undefined;
+    agent?: string | string[] | undefined;
+    agentClass?: string | string[] | undefined;
+    severity?: string | string[] | undefined;
+};
+export declare function parseAgentActivityPage(value: unknown): {
+    items: AgentActivityEvent[];
+    cursor: number;
+};
+export declare function parseAgentReplayRequest(value: unknown): {
+    includeDiagnostics: boolean;
+    includePayloads: boolean;
+    at?: string | undefined;
+    cursor?: string | null | undefined;
+    workdayId?: string | undefined;
+};
+export declare function parseAgentTranscriptPayload(value: unknown): {
+    entries: Record<string, unknown>[];
+    page: {
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+    executionRunId: string;
+    redactionStatus: "sanitized" | "partially-redacted" | "withheld";
+};

package/dist/agent-capacity/validation/agent-lab-forensics-schema.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+const nonEmpty = z.string().trim().min(1);
+const optionalId = nonEmpty.nullable();
+const jsonRecord = z.record(z.unknown());
+const timestamp = z.string().datetime({ offset: true });
+const agentActivityEventSchema = z.object({
+  id: nonEmpty,
+  sequence: z.number().int().nonnegative(),
+  sourceEventId: nonEmpty,
+  timestamp,
+  teamId: nonEmpty,
+  projectId: optionalId,
+  workdayId: nonEmpty,
+  assignmentId: optionalId,
+  modeRunId: optionalId,
+  executionRunId: optionalId,
+  agentId: optionalId,
+  agentClassId: optionalId,
+  activityType: optionalId,
+  handlerId: optionalId,
+  capacityProviderId: optionalId,
+  providerManagerId: optionalId,
+  runnerId: optionalId,
+  executionProviderId: optionalId,
+  eventType: nonEmpty,
+  severity: z.enum(["debug", "info", "warning", "error"]),
+  summary: nonEmpty,
+  transcriptRef: optionalId,
+  artifactRefs: z.array(jsonRecord),
+  contextPackDigest: optionalId,
+  usageDelta: jsonRecord,
+  durationMs: z.number().nonnegative().finite().nullable(),
+  errorCategory: optionalId,
+  recoveryState: optionalId,
+  redactionStatus: nonEmpty,
+  payloadDigest: z.string()
+}).strict();
+const csvFilter = z.union([z.string(), z.array(nonEmpty)]).optional();
+const agentActivityQuerySchema = z.object({
+  after: z.coerce.number().int().min(-1).default(-1),
+  limit: z.coerce.number().int().min(1).max(200).default(100),
+  agent: csvFilter,
+  agentClass: csvFilter,
+  type: csvFilter,
+  severity: csvFilter
+}).strict();
+const agentActivityPageSchema = z.object({
+  items: z.array(agentActivityEventSchema).max(200),
+  cursor: z.number().int().min(-1)
+}).strict();
+const agentReplayRequestSchema = z.object({
+  workdayId: nonEmpty.optional(),
+  at: timestamp.optional(),
+  cursor: z.string().nullable().optional(),
+  includeDiagnostics: z.boolean().default(false),
+  includePayloads: z.boolean().default(false)
+}).strict().superRefine((value, context) => {
+  if (!value.at && !value.cursor) context.addIssue({ code: z.ZodIssueCode.custom, path: ["at"], message: "Provide an exact timestamp or replay cursor." });
+});
+const agentTranscriptPayloadSchema = z.object({
+  executionRunId: nonEmpty,
+  redactionStatus: z.enum(["sanitized", "partially-redacted", "withheld"]),
+  entries: z.array(jsonRecord),
+  page: z.object({
+    limit: z.number().int().positive().max(200),
+    hasMore: z.boolean(),
+    nextCursor: z.string().nullable()
+  }).strict()
+}).strict();
+const agentForensicPayloadSchema = z.object({
+  contract: z.literal("treeseed.agent-forensic-payload/v1"),
+  activity: agentActivityEventSchema,
+  payload: jsonRecord.optional(),
+  transcript: agentTranscriptPayloadSchema.optional(),
+  diagnostics: z.array(z.object({ code: nonEmpty, path: z.string(), message: nonEmpty, severity: z.enum(["info", "warning", "error"]) }).strict()).default([])
+}).strict();
+function parseAgentActivityEvent(value) {
+  return agentActivityEventSchema.parse(value);
+}
+function parseAgentActivityQuery(value) {
+  return agentActivityQuerySchema.parse(value);
+}
+function parseAgentActivityPage(value) {
+  return agentActivityPageSchema.parse(value);
+}
+function parseAgentReplayRequest(value) {
+  return agentReplayRequestSchema.parse(value);
+}
+function parseAgentTranscriptPayload(value) {
+  return agentTranscriptPayloadSchema.parse(value);
+}
+export {
+  agentActivityEventSchema,
+  agentActivityPageSchema,
+  agentActivityQuerySchema,
+  agentForensicPayloadSchema,
+  agentReplayRequestSchema,
+  agentTranscriptPayloadSchema,
+  parseAgentActivityEvent,
+  parseAgentActivityPage,
+  parseAgentActivityQuery,
+  parseAgentReplayRequest,
+  parseAgentTranscriptPayload
+};

package/dist/agent-capacity/validation/agent-signal.d.ts

@@ -0,0 +1,30 @@
+export declare const AGENT_SIGNAL_SCHEMA: "treeseed.agent-signal/v1";
+export declare const AGENT_SIGNAL_ORIGINS: readonly ["treedx-change", "deterministic-handler", "agent-tool"];
+export interface AgentSignalContract {
+    schemaVersion: typeof AGENT_SIGNAL_SCHEMA;
+    id: string;
+    label: string;
+    description: string;
+    subjectKinds: string[];
+    allowedOrigins: Array<typeof AGENT_SIGNAL_ORIGINS[number]>;
+    payloadSchema: Record<string, unknown>;
+    filterableFields?: string[];
+    commitEvidence: 'required' | 'optional' | 'forbidden';
+    allowedProducerProfiles?: string[];
+    subscriberActivityProfiles?: string[];
+    idempotency: 'causation-subject' | 'commit-subject' | 'explicit-key';
+    supersession: 'append' | 'replace-subject' | 'replace-correlation';
+    coalescing: 'none' | 'latest-subject';
+    evidenceRequirements?: string[];
+    relationSemantics?: string[];
+}
+export interface AgentSignalValidation {
+    ok: boolean;
+    diagnostics: Array<{
+        code: string;
+        path: string;
+        message: string;
+    }>;
+    value?: AgentSignalContract;
+}
+export declare function validateAgentSignalContract(value: unknown): AgentSignalValidation;

package/dist/agent-capacity/validation/agent-signal.js

@@ -0,0 +1,31 @@
+const AGENT_SIGNAL_SCHEMA = "treeseed.agent-signal/v1";
+const AGENT_SIGNAL_ORIGINS = ["treedx-change", "deterministic-handler", "agent-tool"];
+function record(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function strings(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.trim());
+}
+function validateAgentSignalContract(value) {
+  const diagnostics = [];
+  if (!record(value)) return { ok: false, diagnostics: [{ code: "agent_signal_invalid", path: "", message: "Signal contract must be an object." }] };
+  const text = (key) => {
+    if (typeof value[key] !== "string" || !String(value[key]).trim()) diagnostics.push({ code: "agent_signal_text_required", path: key, message: `${key} must be a non-empty string.` });
+  };
+  if (value.schemaVersion !== AGENT_SIGNAL_SCHEMA) diagnostics.push({ code: "agent_signal_schema_invalid", path: "schemaVersion", message: `schemaVersion must be ${AGENT_SIGNAL_SCHEMA}.` });
+  for (const key of ["id", "label", "description"]) text(key);
+  for (const key of ["subjectKinds", "allowedOrigins"]) if (!strings(value[key])) diagnostics.push({ code: "agent_signal_list_required", path: key, message: `${key} must contain non-empty strings.` });
+  if (Array.isArray(value.allowedOrigins) && value.allowedOrigins.some((origin) => !AGENT_SIGNAL_ORIGINS.includes(origin))) diagnostics.push({ code: "agent_signal_origin_invalid", path: "allowedOrigins", message: "allowedOrigins contains an unsupported origin." });
+  if (!record(value.payloadSchema)) diagnostics.push({ code: "agent_signal_payload_schema_invalid", path: "payloadSchema", message: "payloadSchema must be an object." });
+  if (!["required", "optional", "forbidden"].includes(String(value.commitEvidence))) diagnostics.push({ code: "agent_signal_commit_policy_invalid", path: "commitEvidence", message: "commitEvidence must be required, optional, or forbidden." });
+  if (!["causation-subject", "commit-subject", "explicit-key"].includes(String(value.idempotency))) diagnostics.push({ code: "agent_signal_idempotency_invalid", path: "idempotency", message: "Unknown idempotency policy." });
+  if (!["append", "replace-subject", "replace-correlation"].includes(String(value.supersession))) diagnostics.push({ code: "agent_signal_supersession_invalid", path: "supersession", message: "Unknown supersession policy." });
+  if (!["none", "latest-subject"].includes(String(value.coalescing))) diagnostics.push({ code: "agent_signal_coalescing_invalid", path: "coalescing", message: "Unknown coalescing policy." });
+  for (const key of ["filterableFields", "allowedProducerProfiles", "subscriberActivityProfiles", "evidenceRequirements", "relationSemantics"]) if (value[key] !== void 0 && !strings(value[key])) diagnostics.push({ code: "agent_signal_list_invalid", path: key, message: `${key} must contain non-empty strings.` });
+  return diagnostics.length ? { ok: false, diagnostics } : { ok: true, diagnostics, value };
+}
+export {
+  AGENT_SIGNAL_ORIGINS,
+  AGENT_SIGNAL_SCHEMA,
+  validateAgentSignalContract
+};

package/dist/agent-capacity/validation/allocation.d.ts

@@ -0,0 +1,12 @@
+import type { CapacityAllocationSetV2, CapacityGrantV2 } from '../allocation.js';
+export interface CapacityAllocationDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export interface CapacityAllocationValidation {
+    ok: boolean;
+    diagnostics: CapacityAllocationDiagnostic[];
+}
+export declare function validateCapacityGrantV2(grant: CapacityGrantV2): CapacityAllocationValidation;
+export declare function validateCapacityAllocationSetV2(set: CapacityAllocationSetV2): CapacityAllocationValidation;