@ai-dev-orchestrator/schemas 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI Dev Orchestrator Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# @ai-dev-orchestrator/schemas
+
+Shared Zod schemas and inferred TypeScript types that define every data structure in the platform. All other packages depend on these schemas for type-safe validation at runtime boundaries.
+
+## Architecture Layer
+
+**Foundation** -- provides the canonical type definitions that all higher layers import.
+
+## Workspace Dependencies
+
+None (only external dependency: `zod`).
+
+## Structure
+
+```
+src/
+  shared/
+  artifacts/
+  config/
+  dashboard/
+  governance/
+  observability/
+  persistence/
+  runner/
+  specification/
+  workflow/
+```
+
+## Key Exports
+
+Each sub-module exports Zod schemas (camelCase, `*Schema` suffix) and inferred TypeScript types (PascalCase). Representative exports per group:
+
+**shared** -- `runIdSchema`/`RunId`, `workerIdSchema`/`WorkerId`, branded ID types, `Result`/`ok`/`err` monad, string enums (`ThreeTierSeverity`, `SessionTransport`, `LiveRequestKind`), `safeParseResponse`.
+
+**artifacts** -- `ARTIFACT_TYPES`, `artifactTypeSchema`/`ArtifactType`, `artifactSchema`/`Artifact`, `agreementArtifactSchema`, `dependencyEdgeSchema`, `provenanceRecordSchema`, and 20+ related schemas.
+
+**workflow** -- `workflowDefinitionSchema`, `stateDefinitionSchema`, `transitionDefinitionSchema`, guard and action schemas (16 guard variants, 7 action variants), `engineStateSchema`, `journalEventTypeSchema`, and 15+ event data schemas.
+
+**specification** -- `canonicalSpecificationSchema`, `intakeResultSchema`, `iterationContractSchema`, `clarificationQuestionSchema`, and validation/merge result types.
+
+**governance** -- `governanceDecisionSchema`, `policyDefinitionSchema`, `policyResultSchema`, `findingSchema`, `escalationContextSchema`, and 30+ policy/finding types.
+
+**runner** -- `roleIdSchema`/`RoleId`, `ROLE_IDS`, `roleContractSchema`, `dispatchRequestSchema`, `agentSessionSnapshotSchema`, `promptTemplateSchema`, `permissionApprovalEntrySchema`, and 40+ runner/session/prompt types.
+
+**config** -- `mergedConfigurationSchema`, `eventBusConfigSchema`, `EVENT_TYPES`, `eventSchema`, and 40+ event payload schemas (`runStartedDataSchema`, `workerDispatchedDataSchema`, etc.).
+
+**dashboard** -- `runSummaryViewSchema`, `runStateViewSchema`, `workflowStateViewSchema`, `healthResponseSchema`, `runCreationParamsSchema`.
+
+**observability** -- `metricEntrySchema`, `healthCheckResultSchema`, `diagnosticReportSchema`, `performanceSnapshotSchema`.
+
+**persistence** -- `persistedStateSchema`, `runManifestSchema`, `discoveryResultSchema`, `lockHandleSchema`.

package/dist/artifacts/agreement-artifacts.d.ts

@@ -0,0 +1,311 @@
+import { z } from 'zod/v4';
+export declare const agreementTypeSchema: z.ZodEnum<{
+    planning_agreement: "planning_agreement";
+    implementation_agreement: "implementation_agreement";
+    verification_agreement: "verification_agreement";
+    release_agreement: "release_agreement";
+}>;
+export type AgreementType = z.infer<typeof agreementTypeSchema>;
+export declare const approvalStatusSchema: z.ZodEnum<{
+    approved: "approved";
+    conditionally_approved: "conditionally_approved";
+    rejected: "rejected";
+}>;
+export type ApprovalStatus = z.infer<typeof approvalStatusSchema>;
+export declare const approvalTypeSchema: z.ZodEnum<{
+    human: "human";
+    automated: "automated";
+    judge: "judge";
+}>;
+export type ApprovalType = z.infer<typeof approvalTypeSchema>;
+export declare const participantActionSchema: z.ZodEnum<{
+    approved: "approved";
+    produced: "produced";
+    reviewed: "reviewed";
+    judged: "judged";
+}>;
+export type ParticipantAction = z.infer<typeof participantActionSchema>;
+export declare const agreementParticipantSchema: z.ZodObject<{
+    role: z.ZodString;
+    action: z.ZodEnum<{
+        approved: "approved";
+        produced: "produced";
+        reviewed: "reviewed";
+        judged: "judged";
+    }>;
+}, z.core.$strip>;
+export type AgreementParticipant = z.infer<typeof agreementParticipantSchema>;
+export declare const agreementFindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodString;
+    status: z.ZodString;
+    title: z.ZodString;
+    resolutionRef: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgreementFinding = z.infer<typeof agreementFindingSchema>;
+export declare const agreementArtifactSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_agreement: "release_agreement";
+    }>;
+    runId: z.ZodString;
+    stageId: z.ZodString;
+    timestamp: z.ZodString;
+    participants: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        action: z.ZodEnum<{
+            approved: "approved";
+            produced: "produced";
+            reviewed: "reviewed";
+            judged: "judged";
+        }>;
+    }, z.core.$strip>>>;
+    reviewedArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    findings: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodString;
+        status: z.ZodString;
+        title: z.ZodString;
+        resolutionRef: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                intake_requirements: "intake_requirements";
+                canonical_specification: "canonical_specification";
+                clarification_questions: "clarification_questions";
+                clarification_answers: "clarification_answers";
+                plan: "plan";
+                plan_review: "plan_review";
+                test_plan: "test_plan";
+                implementation: "implementation";
+                static_review: "static_review";
+                security_review: "security_review";
+                performance_review: "performance_review";
+                adversarial_review: "adversarial_review";
+                design_review: "design_review";
+                docs_review: "docs_review";
+                ux_review: "ux_review";
+                review_report: "review_report";
+                remediation_plan: "remediation_plan";
+                verification: "verification";
+                judge_decision: "judge_decision";
+                planning_agreement: "planning_agreement";
+                implementation_agreement: "implementation_agreement";
+                verification_agreement: "verification_agreement";
+                release_summary: "release_summary";
+                release_agreement: "release_agreement";
+                escalation_context: "escalation_context";
+                run_manifest: "run_manifest";
+                codebase_context: "codebase_context";
+                test_suite: "test_suite";
+                acceptance_validation: "acceptance_validation";
+                review_findings: "review_findings";
+                task_breakdown: "task_breakdown";
+                decomposition_review: "decomposition_review";
+                task_specifications: "task_specifications";
+                pr_diff_context: "pr_diff_context";
+            }>;
+            name: z.ZodString;
+            version: z.ZodNumber;
+            checksum: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    unresolvedFindings: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodString;
+        status: z.ZodString;
+        title: z.ZodString;
+        resolutionRef: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                intake_requirements: "intake_requirements";
+                canonical_specification: "canonical_specification";
+                clarification_questions: "clarification_questions";
+                clarification_answers: "clarification_answers";
+                plan: "plan";
+                plan_review: "plan_review";
+                test_plan: "test_plan";
+                implementation: "implementation";
+                static_review: "static_review";
+                security_review: "security_review";
+                performance_review: "performance_review";
+                adversarial_review: "adversarial_review";
+                design_review: "design_review";
+                docs_review: "docs_review";
+                ux_review: "ux_review";
+                review_report: "review_report";
+                remediation_plan: "remediation_plan";
+                verification: "verification";
+                judge_decision: "judge_decision";
+                planning_agreement: "planning_agreement";
+                implementation_agreement: "implementation_agreement";
+                verification_agreement: "verification_agreement";
+                release_summary: "release_summary";
+                release_agreement: "release_agreement";
+                escalation_context: "escalation_context";
+                run_manifest: "run_manifest";
+                codebase_context: "codebase_context";
+                test_suite: "test_suite";
+                acceptance_validation: "acceptance_validation";
+                review_findings: "review_findings";
+                task_breakdown: "task_breakdown";
+                decomposition_review: "decomposition_review";
+                task_specifications: "task_specifications";
+                pr_diff_context: "pr_diff_context";
+            }>;
+            name: z.ZodString;
+            version: z.ZodNumber;
+            checksum: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    approvalStatus: z.ZodEnum<{
+        approved: "approved";
+        conditionally_approved: "conditionally_approved";
+        rejected: "rejected";
+    }>;
+    approvalType: z.ZodEnum<{
+        human: "human";
+        automated: "automated";
+        judge: "judge";
+    }>;
+    conditions: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgreementArtifact = z.infer<typeof agreementArtifactSchema>;
+export declare const agreementValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    warnings: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type AgreementValidationResult = z.infer<typeof agreementValidationResultSchema>;
+export declare const agreementGateResultSchema: z.ZodObject<{
+    exists: z.ZodBoolean;
+    valid: z.ZodBoolean;
+    approvalStatus: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        conditionally_approved: "conditionally_approved";
+        rejected: "rejected";
+    }>>;
+    artifactRef: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgreementGateResult = z.infer<typeof agreementGateResultSchema>;

package/dist/artifacts/agreement-artifacts.js

@@ -0,0 +1,48 @@
+import { z } from 'zod/v4';
+import { artifactRefSchema } from './artifact-system';
+export const agreementTypeSchema = z.enum([
+    'planning_agreement',
+    'implementation_agreement',
+    'verification_agreement',
+    'release_agreement',
+]);
+export const approvalStatusSchema = z.enum(['approved', 'conditionally_approved', 'rejected']);
+export const approvalTypeSchema = z.enum(['human', 'automated', 'judge']);
+export const participantActionSchema = z.enum(['produced', 'reviewed', 'judged', 'approved']);
+export const agreementParticipantSchema = z.object({
+    role: z.string(),
+    action: participantActionSchema,
+});
+export const agreementFindingSchema = z.object({
+    id: z.string(),
+    severity: z.string(),
+    status: z.string(),
+    title: z.string(),
+    resolutionRef: artifactRefSchema.optional(),
+});
+export const agreementArtifactSchema = z.object({
+    type: agreementTypeSchema,
+    runId: z.string(),
+    stageId: z.string(),
+    timestamp: z.string(),
+    participants: z.array(agreementParticipantSchema).readonly(),
+    reviewedArtifacts: z.array(artifactRefSchema).readonly(),
+    findings: z.array(agreementFindingSchema).readonly(),
+    unresolvedFindings: z.array(agreementFindingSchema).readonly(),
+    approvalStatus: approvalStatusSchema,
+    approvalType: approvalTypeSchema,
+    conditions: z.string().optional(),
+    notes: z.string().optional(),
+});
+export const agreementValidationResultSchema = z.object({
+    valid: z.boolean(),
+    errors: z.array(z.string()).readonly(),
+    warnings: z.array(z.string()).readonly(),
+});
+export const agreementGateResultSchema = z.object({
+    exists: z.boolean(),
+    valid: z.boolean(),
+    approvalStatus: approvalStatusSchema.optional(),
+    artifactRef: artifactRefSchema.optional(),
+    reason: z.string().optional(),
+});