From d25af7bb56ea5dc29c0e56aa1678098fb713b828 Mon Sep 17 00:00:00 2001
From: Bryan <bryan.duran@jpl.nasa.gov>
Date: Tue, 19 Mar 2024 19:10:01 -0600
Subject: [PATCH] Shared scheduling MVP (#1149)

* split scheduling into metadata and definition
* added AssociationForm and DefinitionEditor components
* order analyses by descending id
* fix editors not loading in preselected models on page load
* filter out scheduling items that are private
* make constraints/scheduling columns 50/50

---------

Co-authored-by: Aaron Plave <aaron.plave@jpl.nasa.gov>
---
 e2e-tests/fixtures/Constraints.ts             |   4 +-
 e2e-tests/fixtures/Plan.ts                    |  21 +-
 e2e-tests/fixtures/SchedulingConditions.ts    |  16 +-
 e2e-tests/fixtures/SchedulingGoals.ts         |  15 +-
 e2e-tests/tests/scheduling.test.ts            |   1 +
 .../constraints/ConstraintForm.svelte         | 659 +++-----------
 src/components/constraints/Constraints.svelte |  95 +-
 ...ManagePlanSchedulingConditionsModal.svelte | 351 ++++++++
 .../ManagePlanSchedulingGoalsModal.svelte     | 341 +++++++
 src/components/scheduling/Scheduling.svelte   |  98 +-
 .../SchedulingConditionsPanel.svelte          | 148 +++-
 .../scheduling/SchedulingEditor.svelte        |  53 --
 .../scheduling/SchedulingGoalsPanel.svelte    | 164 ++--
 .../conditions/SchedulingCondition.svelte     | 124 ++-
 .../SchedulingConditionEditor.svelte          |  53 --
 .../conditions/SchedulingConditionForm.svelte | 482 +++++-----
 .../conditions/SchedulingConditions.svelte    | 214 +++--
 .../scheduling/goals/SchedulingGoal.svelte    | 163 ++--
 .../goals/SchedulingGoalForm.svelte           | 562 ++++--------
 .../goals/SchedulingGoalForm.svelte.test.ts   |  45 +-
 .../scheduling/goals/SchedulingGoals.svelte   | 251 +++---
 .../sequencing/SequenceEditor.svelte          |  65 +-
 .../ui/Association/AssociationForm.svelte     | 574 ++++++++++++
 .../Association/DefinitionEditor.svelte}      |  53 +-
 src/components/ui/MonacoEditor.svelte         |  15 +-
 src/routes/constraints/edit/[id]/+page.svelte |   2 +-
 src/routes/constraints/new/+page.svelte       |  13 +-
 src/routes/plans/[id]/+page.svelte            |   2 +-
 src/routes/plans/[id]/+page.ts                |   2 +-
 src/routes/scheduling/+page.svelte            |   2 +-
 src/routes/scheduling/+page.ts                |   5 -
 .../conditions/edit/[id]/+page.svelte         |  99 ++-
 .../scheduling/conditions/edit/[id]/+page.ts  |  19 +-
 .../scheduling/conditions/new/+page.svelte    |  26 +-
 src/routes/scheduling/conditions/new/+page.ts |  16 +-
 .../scheduling/goals/edit/[id]/+page.svelte   | 100 ++-
 .../scheduling/goals/edit/[id]/+page.ts       |  22 +-
 src/routes/scheduling/goals/new/+page.svelte  |  26 +-
 src/routes/scheduling/goals/new/+page.ts      |  16 +-
 src/stores/constraints.ts                     |   3 +-
 src/stores/scheduling.ts                      | 228 ++---
 src/types/constraint.ts                       |  36 +-
 src/types/metadata.ts                         |  34 +
 src/types/plan.ts                             |   4 +-
 src/types/scheduling.ts                       | 197 ++--
 src/types/tags.ts                             |  26 +
 src/utilities/effects.ts                      | 838 ++++++++++++------
 src/utilities/gql.ts                          | 683 +++++++++-----
 src/utilities/modal.ts                        |  72 ++
 src/utilities/permissions.ts                  | 235 +++--
 src/utilities/scheduling.ts                   |  45 +
 51 files changed, 4518 insertions(+), 2800 deletions(-)
 create mode 100644 src/components/modals/ManagePlanSchedulingConditionsModal.svelte
 create mode 100644 src/components/modals/ManagePlanSchedulingGoalsModal.svelte
 delete mode 100644 src/components/scheduling/SchedulingEditor.svelte
 delete mode 100644 src/components/scheduling/conditions/SchedulingConditionEditor.svelte
 create mode 100644 src/components/ui/Association/AssociationForm.svelte
 rename src/components/{constraints/ConstraintEditor.svelte => ui/Association/DefinitionEditor.svelte} (63%)
 create mode 100644 src/types/metadata.ts
 create mode 100644 src/utilities/scheduling.ts

diff --git a/e2e-tests/fixtures/Constraints.ts b/e2e-tests/fixtures/Constraints.ts
index 76672893ee..196e9cdde0 100644
--- a/e2e-tests/fixtures/Constraints.ts
+++ b/e2e-tests/fixtures/Constraints.ts
@@ -85,9 +85,9 @@ export class Constraints {
     this.confirmModal = page.locator(`.modal:has-text("Delete Constraint")`);
     this.confirmModalDeleteButton = page.locator(`.modal:has-text("Delete Constraint") >> button:has-text("Delete")`);
     this.inputConstraintDefinition = page.locator('.monaco-editor >> textarea.inputarea');
-    this.inputConstraintDescription = page.locator('textarea[name="constraint-description"]');
+    this.inputConstraintDescription = page.locator('textarea[name="metadata-description"]');
     this.inputConstraintModel = page.locator(this.inputConstraintModelSelector);
-    this.inputConstraintName = page.locator('input[name="constraint-name"]');
+    this.inputConstraintName = page.locator('input[name="metadata-name"]');
     this.page = page;
     this.saveButton = page.locator(`button:has-text("Save")`);
     this.tableRow = page.locator(`.ag-row:has-text("${this.constraintName}")`);
diff --git a/e2e-tests/fixtures/Plan.ts b/e2e-tests/fixtures/Plan.ts
index 694a38b60d..7eb1cc18d6 100644
--- a/e2e-tests/fixtures/Plan.ts
+++ b/e2e-tests/fixtures/Plan.ts
@@ -41,12 +41,14 @@ export class Plan {
   scheduleButton: Locator;
   schedulingConditionEnabledCheckbox: Locator;
   schedulingConditionListItemSelector: string;
+  schedulingConditionManageButton: Locator;
   schedulingConditionNewButton: Locator;
   schedulingGoal: Locator;
   schedulingGoalDifferenceBadge: Locator;
   schedulingGoalEnabledCheckboxSelector: (goalName: string) => Locator;
   schedulingGoalExpand: Locator;
   schedulingGoalListItemSelector: (goalName: string) => string;
+  schedulingGoalManageButton: Locator;
   schedulingGoalNewButton: Locator;
   schedulingSatisfiedActivity: Locator;
   schedulingStatusSelector: (status: string) => string;
@@ -91,28 +93,34 @@ export class Plan {
   }
 
   async createSchedulingCondition(baseURL: string | undefined) {
+    await this.schedulingConditionManageButton.click();
     const [newSchedulingConditionPage] = await Promise.all([
       this.page.waitForEvent('popup'),
       this.schedulingConditionNewButton.click(),
     ]);
     this.schedulingConditions.updatePage(newSchedulingConditionPage);
-    await newSchedulingConditionPage.waitForURL(`${baseURL}/scheduling/conditions/new?modelId=*&&specId=*`);
+    await newSchedulingConditionPage.waitForURL(`${baseURL}/scheduling/conditions/new?modelId=*`);
     await this.schedulingConditions.createSchedulingCondition(baseURL);
     await newSchedulingConditionPage.close();
     this.schedulingConditions.updatePage(this.page);
+    await this.page.getByRole('row', { name: this.schedulingConditions.conditionName }).getByRole('checkbox').click();
+    await this.page.getByRole('button', { name: 'Update' }).click();
     await this.page.waitForSelector(this.schedulingConditionListItemSelector, { state: 'visible', strict: true });
   }
 
   async createSchedulingGoal(baseURL: string | undefined, goalName: string) {
+    await this.schedulingGoalManageButton.click();
     const [newSchedulingGoalPage] = await Promise.all([
       this.page.waitForEvent('popup'),
       this.schedulingGoalNewButton.click(),
     ]);
     this.schedulingGoals.updatePage(newSchedulingGoalPage);
-    await newSchedulingGoalPage.waitForURL(`${baseURL}/scheduling/goals/new?modelId=*&&specId=*`);
+    await newSchedulingGoalPage.waitForURL(`${baseURL}/scheduling/goals/new?modelId=*`);
     await this.schedulingGoals.createSchedulingGoal(baseURL, goalName);
     await newSchedulingGoalPage.close();
     this.schedulingGoals.updatePage(this.page);
+    await this.page.getByRole('row', { name: goalName }).getByRole('checkbox').click();
+    await this.page.getByRole('button', { name: 'Update' }).click();
     await this.page.waitForSelector(this.schedulingGoalListItemSelector(goalName), { state: 'visible', strict: true });
   }
 
@@ -165,6 +173,13 @@ export class Plan {
     await this.page.locator(this.constraintListItemSelector).waitFor({ state: 'detached' });
   }
 
+  async removeSchedulingGoal(goalName: string) {
+    await this.schedulingGoalManageButton.click();
+    await this.page.getByRole('row', { name: goalName }).getByRole('checkbox').click();
+    await this.page.getByRole('button', { name: 'Update' }).click();
+    await this.page.locator(this.schedulingGoalListItemSelector(goalName)).waitFor({ state: 'detached' });
+  }
+
   async runAnalysis() {
     await this.analyzeButton.click();
     await this.waitForSchedulingStatus('Incomplete');
@@ -330,6 +345,8 @@ export class Plan {
     this.roleSelector = page.locator(`.nav select`);
     this.scheduleButton = page.locator('.header-actions button[aria-label="Schedule"]');
     this.analyzeButton = page.locator('.header-actions button[aria-label="Analyze"]');
+    this.schedulingGoalManageButton = page.locator(`button[name="manage-goals"]`);
+    this.schedulingConditionManageButton = page.locator(`button[name="manage-conditions"]`);
     this.schedulingGoal = page.locator('.scheduling-goal').first();
     this.schedulingGoalDifferenceBadge = this.schedulingGoal.locator('.difference-badge');
     this.schedulingGoalEnabledCheckboxSelector = (goalName: string) =>
diff --git a/e2e-tests/fixtures/SchedulingConditions.ts b/e2e-tests/fixtures/SchedulingConditions.ts
index 646216bed8..5bea4003d7 100644
--- a/e2e-tests/fixtures/SchedulingConditions.ts
+++ b/e2e-tests/fixtures/SchedulingConditions.ts
@@ -1,7 +1,6 @@
 import { expect, type Locator, type Page } from '@playwright/test';
 import { adjectives, animals, colors, uniqueNamesGenerator } from 'unique-names-generator';
 import { fillEditorText } from '../utilities/editor.js';
-import { getOptionValueFromText } from '../utilities/selectors.js';
 import { Models } from './Models.js';
 
 export class SchedulingConditions {
@@ -28,14 +27,12 @@ export class SchedulingConditions {
 
   async createSchedulingCondition(baseURL: string | undefined) {
     await expect(this.saveButton).toBeDisabled();
-    await this.selectModel();
     await this.fillConditionName();
     await this.fillConditionDescription();
     await this.fillConditionDefinition();
     await expect(this.saveButton).not.toBeDisabled();
     await this.saveButton.click();
     await this.page.waitForURL(`${baseURL}/scheduling/conditions/edit/*`);
-    await expect(this.saveButton).not.toBeDisabled();
     await expect(this.closeButton).not.toBeDisabled();
     await this.closeButton.click();
     await this.page.waitForURL(`${baseURL}/scheduling`);
@@ -45,7 +42,6 @@ export class SchedulingConditions {
     await this.goto();
     await expect(this.tableRow).toBeVisible();
     await expect(this.tableRowDeleteButton).not.toBeVisible();
-
     await this.tableRow.hover();
     await this.tableRowDeleteButton.waitFor({ state: 'attached' });
     await this.tableRowDeleteButton.waitFor({ state: 'visible' });
@@ -86,14 +82,6 @@ export class SchedulingConditions {
     await this.page.waitForSelector(`input[placeholder="Filter conditions"]`, { state: 'attached' });
   }
 
-  async selectModel() {
-    await this.page.waitForSelector(`option:has-text("${this.models.modelName}")`, { state: 'attached' });
-    const value = await getOptionValueFromText(this.page, this.inputConditionModelSelector, this.models.modelName);
-    await this.inputConditionModel.focus();
-    await this.inputConditionModel.selectOption(value);
-    await this.inputConditionModel.evaluate(e => e.blur());
-  }
-
   updatePage(page: Page): void {
     this.closeButton = page.locator(`button:has-text("Close")`);
     this.confirmModal = page.locator(`.modal:has-text("Delete Scheduling Condition")`);
@@ -101,9 +89,9 @@ export class SchedulingConditions {
       `.modal:has-text("Delete Scheduling Condition") >> button:has-text("Delete")`,
     );
     this.inputConditionDefinition = page.locator('.monaco-editor >> textarea.inputarea');
-    this.inputConditionDescription = page.locator('textarea[name="condition-description"]');
+    this.inputConditionDescription = page.locator('textarea[name="metadata-description"]');
     this.inputConditionModel = page.locator(this.inputConditionModelSelector);
-    this.inputConditionName = page.locator(`input[name="condition-name"]`);
+    this.inputConditionName = page.locator(`input[name="metadata-name"]`);
     this.newButton = page.locator(`button:has-text("New")`);
     this.page = page;
     this.saveButton = page.locator(`button:has-text("Save")`);
diff --git a/e2e-tests/fixtures/SchedulingGoals.ts b/e2e-tests/fixtures/SchedulingGoals.ts
index 98967b1bcb..9c111cbd68 100644
--- a/e2e-tests/fixtures/SchedulingGoals.ts
+++ b/e2e-tests/fixtures/SchedulingGoals.ts
@@ -1,6 +1,5 @@
 import { expect, type Locator, type Page } from '@playwright/test';
 import { fillEditorText } from '../utilities/editor.js';
-import { getOptionValueFromText } from '../utilities/selectors.js';
 import { Models } from './Models.js';
 
 export class SchedulingGoals {
@@ -25,14 +24,12 @@ export class SchedulingGoals {
 
   async createSchedulingGoal(baseURL: string | undefined, goalName: string) {
     await expect(this.saveButton).toBeDisabled();
-    await this.selectModel();
     await this.fillGoalName(goalName);
     await this.fillGoalDescription();
     await this.fillGoalDefinition();
     await expect(this.saveButton).not.toBeDisabled();
     await this.saveButton.click();
     await this.page.waitForURL(`${baseURL}/scheduling/goals/edit/*`);
-    await expect(this.saveButton).not.toBeDisabled();
     await expect(this.closeButton).not.toBeDisabled();
     await this.closeButton.click();
     await this.page.waitForURL(`${baseURL}/scheduling`);
@@ -83,14 +80,6 @@ export class SchedulingGoals {
     await this.page.waitForSelector(`input[placeholder="Filter goals"]`, { state: 'attached' });
   }
 
-  async selectModel() {
-    await this.page.waitForSelector(`option:has-text("${this.models.modelName}")`, { state: 'attached' });
-    const value = await getOptionValueFromText(this.page, this.inputGoalModelSelector, this.models.modelName);
-    await this.inputGoalModel.focus();
-    await this.inputGoalModel.selectOption(value);
-    await this.inputGoalModel.evaluate(e => e.blur());
-  }
-
   updatePage(page: Page): void {
     this.closeButton = page.locator(`button:has-text("Close")`);
     this.confirmModal = page.locator(`.modal:has-text("Delete Scheduling Goal")`);
@@ -98,9 +87,9 @@ export class SchedulingGoals {
       `.modal:has-text("Delete Scheduling Goal") >> button:has-text("Delete")`,
     );
     this.inputGoalDefinition = page.locator('.monaco-editor >> textarea.inputarea');
-    this.inputGoalDescription = page.locator('textarea[name="goal-description"]');
+    this.inputGoalDescription = page.locator('textarea[name="metadata-description"]');
     this.inputGoalModel = page.locator(this.inputGoalModelSelector);
-    this.inputGoalName = page.locator(`input[name="goal-name"]`);
+    this.inputGoalName = page.locator(`input[name="metadata-name"]`);
     this.newButton = page.locator(`button:has-text("New")`);
     this.page = page;
     this.saveButton = page.locator(`button:has-text("Save")`);
diff --git a/e2e-tests/tests/scheduling.test.ts b/e2e-tests/tests/scheduling.test.ts
index 55f3a19bf3..0dd43d941f 100644
--- a/e2e-tests/tests/scheduling.test.ts
+++ b/e2e-tests/tests/scheduling.test.ts
@@ -117,6 +117,7 @@ test.describe.serial('Scheduling', () => {
   });
 
   test('Delete scheduling goal', async () => {
+    await plan.removeSchedulingGoal(goalName1);
     await schedulingGoals.deleteSchedulingGoal(goalName1);
   });
 });
diff --git a/src/components/constraints/ConstraintForm.svelte b/src/components/constraints/ConstraintForm.svelte
index 16acd07383..1edf51f94f 100644
--- a/src/components/constraints/ConstraintForm.svelte
+++ b/src/components/constraints/ConstraintForm.svelte
@@ -3,36 +3,16 @@
 <script lang="ts">
   import { goto } from '$app/navigation';
   import { base } from '$app/paths';
-  import HideIcon from '@nasa-jpl/stellar/icons/visible_hide.svg?component';
-  import ShowIcon from '@nasa-jpl/stellar/icons/visible_show.svg?component';
   import { createEventDispatcher } from 'svelte';
   import { SearchParameters } from '../../enums/searchParameters';
-  import { constraints, constraintsFormColumns } from '../../stores/constraints';
+  import { constraints } from '../../stores/constraints';
   import type { User, UserId } from '../../types/app';
-  import type { ConstraintDefinition, ConstraintMetadata } from '../../types/constraint';
-  import type {
-    ConstraintDefinitionTagsInsertInput,
-    ConstraintMetadataTagsInsertInput,
-    Tag,
-    TagsChangeEvent,
-  } from '../../types/tags';
+  import type { TypeScriptFile } from '../../types/monaco';
+  import type { ConstraintDefinitionTagsInsertInput, ConstraintMetadataTagsInsertInput, Tag } from '../../types/tags';
   import effects from '../../utilities/effects';
-  import { getTarget } from '../../utilities/generic';
-  import { permissionHandler } from '../../utilities/permissionHandler';
   import { featurePermissions } from '../../utilities/permissions';
-  import { diffTags } from '../../utilities/tags';
   import PageTitle from '../app/PageTitle.svelte';
-  import CssGrid from '../ui/CssGrid.svelte';
-  import CssGridGutter from '../ui/CssGridGutter.svelte';
-  import Panel from '../ui/Panel.svelte';
-  import RadioButton from '../ui/RadioButtons/RadioButton.svelte';
-  import RadioButtons from '../ui/RadioButtons/RadioButtons.svelte';
-  import SectionTitle from '../ui/SectionTitle.svelte';
-  import TagsInput from '../ui/Tags/TagsInput.svelte';
-  import ConstraintEditor from './ConstraintEditor.svelte';
-
-  type SavedConstraintMetadata = Pick<ConstraintMetadata, 'description' | 'name' | 'owner' | 'public' | 'tags'>;
-  type SavedConstraintDefinition = Pick<ConstraintDefinition, 'definition' | 'tags'>;
+  import AssociationForm from '../ui/Association/AssociationForm.svelte';
 
   export let initialConstraintDefinitionAuthor: UserId | undefined = undefined;
   export let initialConstraintDefinitionCode: string = 'export default (): Constraint => {\n\n}\n';
@@ -54,221 +34,97 @@
 
   const permissionError = `You do not have permission to ${mode === 'edit' ? 'edit this' : 'create a'} constraint.`;
 
-  let constraintDefintionAuthor: UserId | null = initialConstraintDefinitionAuthor ?? user?.id ?? null;
-  let constraintDefinitionCode: string = initialConstraintDefinitionCode;
-  let constraintDefinitionTags: Tag[] = initialConstraintDefinitionTags;
-  let constraintDescription: string = initialConstraintDescription;
-  let constraintMetadataId: number | null = initialConstraintId;
-  let constraintMetadataTags: Tag[] = initialConstraintMetadataTags;
-  let constraintName: string = initialConstraintName;
-  let constraintNameError: string = '';
-  let constraintOwner: UserId = initialConstraintOwner ?? user?.id ?? null;
-  let constraintPublic: boolean = initialConstraintPublic;
   let hasCreateDefinitionCodePermission: boolean = false;
-  let hasUpdateDefinitionPermission: boolean = false;
   let hasWriteMetadataPermission: boolean = false;
-  let isDefinitionModified: boolean = false;
-  let isDefinitionDataModified: boolean = false;
-  let isMetadataModified: boolean = false;
-  let referenceModelId: number | null = initialReferenceModelId;
-  let saveButtonEnabled: boolean = false;
-  let saveButtonText: string = 'Save';
-  let savedConstraintMetadata: SavedConstraintMetadata = {
-    description: constraintDescription,
-    name: constraintName,
-    owner: constraintOwner,
-    public: constraintPublic,
-    tags: constraintMetadataTags.map(tag => ({ tag })),
-  };
-  let savedConstraintDefinition: SavedConstraintDefinition = {
-    definition: constraintDefinitionCode,
-    tags: constraintDefinitionTags.map(tag => ({ tag })),
-  };
-
-  $: {
-    savedConstraintMetadata = {
-      description: initialConstraintDescription,
-      name: initialConstraintName,
-      owner: initialConstraintOwner,
-      public: initialConstraintPublic,
-      tags: initialConstraintMetadataTags.map(tag => ({ tag })),
-    };
-    constraintOwner = initialConstraintOwner ?? user?.id ?? null;
-  }
-  $: {
-    savedConstraintDefinition = {
-      definition: initialConstraintDefinitionCode,
-      tags: initialConstraintDefinitionTags.map(tag => ({ tag })),
-    };
-    constraintDefintionAuthor = initialConstraintDefinitionAuthor ?? user?.id ?? null;
-    constraintDefinitionCode = initialConstraintDefinitionCode;
-    constraintDefinitionTags = initialConstraintDefinitionTags;
-  }
+  let pageTitle = mode === 'edit' ? 'Constraints' : 'New Constraint';
+  let pageSubtitle = mode === 'edit' ? initialConstraintName : '';
+  let constraintsTsFiles: TypeScriptFile[] = [];
 
-  $: isMetadataModified = diffConstraintMetadata(savedConstraintMetadata, {
-    description: constraintDescription,
-    name: constraintName,
-    owner: constraintOwner,
-    public: constraintPublic,
-    tags: constraintMetadataTags.map(tag => ({ tag })),
-  });
-  $: isDefinitionModified = diffConstraintDefinition(savedConstraintDefinition, {
-    definition: constraintDefinitionCode,
-  });
-  $: isDefinitionDataModified = diffTags(
-    (savedConstraintDefinition.tags || []).map(({ tag }) => tag),
-    constraintDefinitionTags,
-  );
   $: hasCreateDefinitionCodePermission = featurePermissions.constraints.canCreate(user);
-  $: hasUpdateDefinitionPermission =
-    user?.id === constraintDefintionAuthor || user?.id === constraintOwner || isDefinitionModified;
   $: hasWriteMetadataPermission =
     mode === 'create'
       ? featurePermissions.constraints.canCreate(user)
       : featurePermissions.constraints.canUpdate(user, { owner: initialConstraintOwner });
-
   $: pageTitle = mode === 'edit' ? 'Constraints' : 'New Constraint';
-  $: pageSubtitle = mode === 'edit' ? savedConstraintMetadata.name : '';
-  $: referenceModelId = initialReferenceModelId;
-  $: saveButtonEnabled =
-    constraintNameError === '' &&
-    constraintOwner !== '' &&
-    constraintDefinitionCode !== '' &&
-    constraintName !== '' &&
-    (isMetadataModified || isDefinitionDataModified || isDefinitionModified);
-  $: saveButtonClass = saveButtonEnabled ? 'primary' : 'secondary';
-  $: if (mode === 'edit' && (isMetadataModified || isDefinitionModified)) {
-    saveButtonText = 'Saved';
-    if ((isMetadataModified || isDefinitionDataModified) && !isDefinitionModified) {
-      saveButtonText = 'Save';
-    } else if (isDefinitionModified) {
-      saveButtonText = 'Save as new version';
-    }
-  } else {
-    saveButtonText = 'Save';
-  }
-  $: if (constraintPublic && constraintName) {
-    const existingMetadata = $constraints.find(
-      ({ name, public: publicConstraint }) => name === constraintName && publicConstraint,
-    );
-    if (existingMetadata !== undefined && existingMetadata.id !== constraintMetadataId) {
-      constraintNameError = 'Constraint name must be unique when public';
-    } else {
-      constraintNameError = '';
-    }
-  } else {
-    constraintNameError = '';
-  }
+  $: pageSubtitle = mode === 'edit' ? initialConstraintName : '';
+  $: selectReferenceModel(initialReferenceModelId);
 
-  function diffConstraintMetadata(
-    constraintMetadataA: SavedConstraintMetadata,
-    constraintMetadataB: SavedConstraintMetadata,
-  ) {
-    if (
-      constraintMetadataA.description !== constraintMetadataB.description ||
-      constraintMetadataA.name !== constraintMetadataB.name ||
-      constraintMetadataA.public !== constraintMetadataB.public ||
-      constraintMetadataA.owner !== constraintMetadataB.owner ||
-      diffTags(
-        (constraintMetadataA.tags || []).map(({ tag }) => tag),
-        (constraintMetadataB.tags || []).map(({ tag }) => tag),
-      )
-    ) {
-      return true;
+  function selectReferenceModel(modelId: number | null) {
+    if (modelId !== null) {
+      effects.getTsFilesScheduling(modelId, user).then(tsFiles => (constraintsTsFiles = tsFiles));
+    } else {
+      constraintsTsFiles = [];
     }
-
-    return false;
   }
 
-  function diffConstraintDefinition(
-    constraintDefinitionA: Pick<SavedConstraintDefinition, 'definition'>,
-    constraintDefinitionB: Pick<SavedConstraintDefinition, 'definition'>,
-  ) {
-    return constraintDefinitionA.definition !== constraintDefinitionB.definition;
+  function selectRevision(revision: number | string) {
+    dispatch('selectRevision', parseInt(`${revision}`));
   }
 
-  function onDidChangeModelContent(event: CustomEvent<{ value: string }>) {
+  function onRevisionSelection(event: CustomEvent<number>) {
     const { detail } = event;
-    const { value } = detail;
-    constraintDefinitionCode = value;
-  }
 
-  async function onDefinitionTagsInputChange(event: TagsChangeEvent) {
-    const {
-      detail: { tag, type },
-    } = event;
-    if (type === 'remove') {
-      constraintDefinitionTags = constraintDefinitionTags.filter(t => t.name !== tag.name);
-    } else if (type === 'create' || type === 'select') {
-      let tagsToAdd: Tag[] = [tag];
-      if (type === 'create') {
-        tagsToAdd = (await effects.createTags([{ color: tag.color, name: tag.name }], user)) || [];
-      }
-      constraintDefinitionTags = constraintDefinitionTags.concat(tagsToAdd);
-    }
+    selectRevision(`${detail}`);
   }
 
-  async function onMetadataTagsInputChange(event: TagsChangeEvent) {
-    const {
-      detail: { tag, type },
-    } = event;
-    if (type === 'remove') {
-      constraintMetadataTags = constraintMetadataTags.filter(t => t.name !== tag.name);
-    } else if (type === 'create' || type === 'select') {
-      let tagsToAdd: Tag[] = [tag];
-      if (type === 'create') {
-        tagsToAdd = (await effects.createTags([{ color: tag.color, name: tag.name }], user)) || [];
-      }
-      constraintMetadataTags = constraintMetadataTags.concat(tagsToAdd);
-    }
-  }
-
-  function onSetPublic(event: CustomEvent<{ id: 'public' | 'private' }>) {
+  function onSelectReferenceModel(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    selectReferenceModel(modelId);
+    dispatch('selectReferenceModel', modelId);
+  }
+
+  function onClose() {
+    goto(`${base}/constraints`);
+  }
+
+  async function onCreateConstraint(
+    event: CustomEvent<{
+      definition: {
+        code: string;
+        tags: Tag[];
+      };
+      description: string;
+      name: string;
+      public: boolean;
+      tags: Tag[];
+    }>,
+  ) {
     const {
-      detail: { id },
+      detail: { definition, description, name, public: isPublic, tags },
     } = event;
+    const newConstraintId = await effects.createConstraint(
+      name,
+      isPublic,
+      tags.map(({ id }) => ({ tag_id: id })),
+      definition.code,
+      definition.tags.map(({ id }) => ({ tag_id: id })),
+      user,
+      description,
+    );
 
-    constraintPublic = id === 'public';
-  }
-
-  function selectRevision(revision: number | string) {
-    dispatch('selectRevision', parseInt(`${revision}`));
-  }
-
-  function onRevisionSelection(event: Event) {
-    const { value } = getTarget(event);
-
-    selectRevision(`${value}`);
-  }
-
-  async function createConstraint() {
-    if (saveButtonEnabled) {
-      const newConstraintId = await effects.createConstraint(
-        constraintName,
-        constraintPublic,
-        constraintMetadataTags.map(({ id }) => ({ tag_id: id })),
-        constraintDefinitionCode,
-        constraintDefinitionTags.map(({ id }) => ({ tag_id: id })),
-        user,
-        constraintDescription,
+    if (newConstraintId !== null) {
+      goto(
+        `${base}/constraints/edit/${newConstraintId}${
+          initialReferenceModelId !== null ? `?${SearchParameters.MODEL_ID}=${initialReferenceModelId}` : ''
+        }`,
       );
-
-      if (newConstraintId !== null) {
-        goto(
-          `${base}/constraints/edit/${newConstraintId}${
-            referenceModelId !== null ? `?${SearchParameters.MODEL_ID}=${referenceModelId}` : ''
-          }`,
-        );
-      }
     }
   }
 
-  async function createNewConstraintDefinition() {
-    if (saveButtonEnabled && constraintMetadataId !== null) {
+  async function onCreateNewConstraintDefinition(
+    event: CustomEvent<{
+      definitionCode: string;
+      definitionTags: Tag[];
+    }>,
+  ) {
+    const {
+      detail: { definitionCode, definitionTags },
+    } = event;
+    if (initialConstraintId !== null) {
       const definition = await effects.createConstraintDefinition(
-        constraintMetadataId,
-        constraintDefinitionCode,
-        constraintDefinitionTags.map(({ id }) => ({ tag_id: id })),
+        initialConstraintId,
+        definitionCode,
+        definitionTags.map(({ id }) => ({ tag_id: id })),
         user,
       );
 
@@ -278,330 +134,107 @@
     }
   }
 
-  function onSelectReferenceModel(event: CustomEvent<number | null>) {
-    const { detail } = event;
-    referenceModelId = detail;
-    dispatch('selectReferenceModel', detail);
-  }
-
-  async function saveConstraint() {
-    if (constraintMetadataId) {
-      if (isMetadataModified) {
-        await saveConstraintMetadata();
-      }
-      if (isDefinitionDataModified && !isDefinitionModified) {
-        await saveConstraintDefinitionRevisionTags();
-      } else if (isDefinitionModified) {
-        await createNewConstraintDefinition();
-      }
-    } else {
-      await createConstraint();
-    }
-  }
-
-  async function saveConstraintMetadata() {
-    if (constraintMetadataId !== null) {
-      const tagsToUpdate: ConstraintMetadataTagsInsertInput[] = (constraintMetadataTags || []).map(
+  async function onSaveConstraintMetadata(
+    event: CustomEvent<{
+      metadata: {
+        description: string;
+        name: string;
+        owner: UserId;
+        public: boolean;
+      };
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>,
+  ) {
+    if (initialConstraintId !== null) {
+      const {
+        detail: {
+          metadata: { description, name, owner, public: isPublic },
+          tagIdsToDelete,
+          tagsToUpdate,
+        },
+      } = event;
+      const constraintMetadataTagsToUpdate: ConstraintMetadataTagsInsertInput[] = tagsToUpdate.map(
         ({ id: tag_id }) => ({
-          constraint_id: constraintMetadataId as number,
+          constraint_id: initialConstraintId as number,
           tag_id,
         }),
       );
-      // Disassociate old tags from constraint
-      const tagIdsToDelete = savedConstraintMetadata.tags
-        .filter(({ tag }) => !constraintMetadataTags.find(t => tag.id === t.id))
-        .map(({ tag }) => tag.id);
 
-      const updated = await effects.updateConstraintMetadata(
-        constraintMetadataId,
+      await effects.updateConstraintMetadata(
+        initialConstraintId,
         {
-          description: constraintDescription,
-          name: constraintName,
-          owner: constraintOwner,
-          public: constraintPublic,
+          description,
+          name,
+          owner,
+          public: isPublic,
         },
-        tagsToUpdate,
+        constraintMetadataTagsToUpdate,
         tagIdsToDelete,
         initialConstraintOwner,
         user,
       );
-
-      if (updated) {
-        savedConstraintMetadata = {
-          description: constraintDescription,
-          name: constraintName,
-          owner: constraintOwner,
-          public: constraintPublic,
-          tags: constraintMetadataTags.map(tag => ({ tag })),
-        };
-      }
     }
   }
 
-  async function saveConstraintDefinitionRevisionTags() {
-    if (constraintMetadataId !== null && initialConstraintRevision !== null) {
+  async function onSaveConstraintDefinitionRevisionTags(
+    event: CustomEvent<{
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>,
+  ) {
+    if (initialConstraintId !== null && initialConstraintRevision !== null) {
+      const {
+        detail: { tagIdsToDelete, tagsToUpdate },
+      } = event;
       // Associate new tags with constraint definition version
-      const tagsToUpdate: ConstraintDefinitionTagsInsertInput[] = constraintDefinitionTags.map(({ id: tag_id }) => ({
-        constraint_id: constraintMetadataId as number,
-        constraint_revision: initialConstraintRevision as number,
-        tag_id,
-      }));
-
-      // Disassociate old tags from constraint
-      const tagIdsToDelete = initialConstraintDefinitionTags
-        .filter(tag => !constraintDefinitionTags.find(t => tag.id === t.id))
-        .map(tag => tag.id);
+      const constraintDefinitionTagsToUpdate: ConstraintDefinitionTagsInsertInput[] = tagsToUpdate.map(
+        ({ id: tag_id }) => ({
+          constraint_id: initialConstraintId as number,
+          constraint_revision: initialConstraintRevision as number,
+          tag_id,
+        }),
+      );
       await effects.updateConstraintDefinitionTags(
-        constraintMetadataId,
+        initialConstraintId,
         initialConstraintRevision,
-        tagsToUpdate,
+        constraintDefinitionTagsToUpdate,
         tagIdsToDelete,
         user,
       );
     }
   }
-
-  function revertConstraint() {
-    constraintDefintionAuthor = initialConstraintDefinitionAuthor ?? user?.id ?? null;
-    constraintDefinitionCode = initialConstraintDefinitionCode;
-    constraintDefinitionTags = initialConstraintDefinitionTags;
-    constraintDescription = initialConstraintDescription;
-    constraintMetadataId = initialConstraintId;
-    constraintMetadataTags = initialConstraintMetadataTags;
-    constraintName = initialConstraintName;
-    constraintOwner = initialConstraintOwner ?? user?.id ?? null;
-    constraintPublic = initialConstraintPublic;
-  }
 </script>
 
 <PageTitle subTitle={pageSubtitle} title={pageTitle} />
 
-<CssGrid bind:columns={$constraintsFormColumns}>
-  <Panel overflowYBody="hidden" padBody={false}>
-    <svelte:fragment slot="header">
-      <SectionTitle>{mode === 'create' ? 'New Constraint' : 'Edit Constraint'}</SectionTitle>
-
-      <div class="right">
-        <button class="st-button secondary ellipsis" on:click={() => goto(`${base}/constraints`)}>
-          {mode === 'create' ? 'Cancel' : 'Close'}
-        </button>
-        {#if mode === 'edit' && saveButtonEnabled}
-          <button class="st-button secondary ellipsis" on:click={revertConstraint}> Revert </button>
-        {/if}
-        <button
-          class="st-button {saveButtonClass} ellipsis"
-          disabled={!saveButtonEnabled}
-          use:permissionHandler={{
-            hasPermission: saveButtonEnabled,
-            permissionError,
-          }}
-          on:click={saveConstraint}
-        >
-          {saveButtonText}
-        </button>
-      </div>
-    </svelte:fragment>
-
-    <svelte:fragment slot="body">
-      <fieldset>
-        <label for="constraint-name">Name</label>
-        <input
-          bind:value={constraintName}
-          autocomplete="off"
-          class:constraint-form-error={!!constraintNameError}
-          class="st-input w-100"
-          name="constraint-name"
-          placeholder="Enter Constraint Name (required)"
-          required
-          use:permissionHandler={{
-            hasPermission: hasWriteMetadataPermission,
-            permissionError,
-          }}
-        />
-        <div class="constraint-form-error-message">{constraintNameError}</div>
-      </fieldset>
-
-      <fieldset>
-        <label for="constraintOwner">Owner</label>
-        <input
-          bind:value={constraintOwner}
-          class="st-input w-100"
-          name="constraintOwner"
-          placeholder="Enter Constraint Owner Username (required)"
-          use:permissionHandler={{
-            hasPermission: hasWriteMetadataPermission,
-            permissionError,
-          }}
-        />
-      </fieldset>
-
-      <fieldset>
-        <label for="constraint-description">Description</label>
-        <textarea
-          bind:value={constraintDescription}
-          autocomplete="off"
-          class="st-input w-100"
-          name="constraint-description"
-          placeholder="Enter Constraint Description (optional)"
-          use:permissionHandler={{
-            hasPermission: hasWriteMetadataPermission,
-            permissionError,
-          }}
-        />
-      </fieldset>
-
-      <fieldset>
-        <label for="metadataTags">Tags</label>
-        <TagsInput
-          name="metadataTags"
-          use={[
-            [
-              permissionHandler,
-              {
-                hasPermission: hasWriteMetadataPermission,
-                permissionError,
-              },
-            ],
-          ]}
-          options={tags}
-          selected={constraintMetadataTags}
-          on:change={onMetadataTagsInputChange}
-        />
-      </fieldset>
-
-      {#if mode === 'edit'}
-        <fieldset>
-          <label for="constraintId">Constraint ID</label>
-          <input class="st-input w-100" disabled name="constraintId" value={constraintMetadataId} />
-        </fieldset>
-      {/if}
-
-      <fieldset>
-        <label for="public">Visibility</label>
-        <RadioButtons selectedButtonId={constraintPublic ? 'public' : 'private'} on:select-radio-button={onSetPublic}>
-          <RadioButton
-            id="private"
-            use={[
-              [
-                permissionHandler,
-                {
-                  hasPermission: hasWriteMetadataPermission,
-                  permissionError,
-                },
-              ],
-            ]}><div class="public-button"><HideIcon /><span>Private</span></div></RadioButton
-          >
-          <RadioButton
-            id="public"
-            use={[
-              [
-                permissionHandler,
-                {
-                  hasPermission: hasWriteMetadataPermission,
-                  permissionError,
-                },
-              ],
-            ]}><div class="public-button"><ShowIcon /><span>Public</span></div></RadioButton
-          >
-        </RadioButtons>
-      </fieldset>
-
-      <div class="definition-divider" />
-
-      {#if mode === 'edit'}
-        <fieldset>
-          <label for="versions">Version</label>
-          {#if !isDefinitionModified}
-            <select
-              value={initialConstraintRevision}
-              class="st-select w-100"
-              name="versions"
-              on:change={onRevisionSelection}
-            >
-              {#each constraintRevisions as revision}
-                <option value={revision}>
-                  {revision}
-                </option>
-              {/each}
-            </select>
-          {:else}
-            <select disabled class="st-select w-100" name="versions">
-              <option value={constraintRevisions[constraintRevisions.length - 1] + 1}>
-                {constraintRevisions[constraintRevisions.length - 1] + 1} (Next version)
-              </option>
-            </select>
-          {/if}
-        </fieldset>
-      {/if}
-
-      <fieldset>
-        <label for="constraintDefinitionAuthor">Author</label>
-        <input
-          disabled
-          value={constraintDefintionAuthor}
-          class="st-input w-100"
-          name="constraintDefinitionAuthor"
-          use:permissionHandler={{
-            hasPermission: hasWriteMetadataPermission,
-            permissionError,
-          }}
-        />
-      </fieldset>
-
-      <fieldset>
-        <label for="definitionTags">Version Tags</label>
-        <TagsInput
-          name="definitionTags"
-          use={[
-            [
-              permissionHandler,
-              {
-                hasPermission: hasUpdateDefinitionPermission,
-                permissionError,
-              },
-            ],
-          ]}
-          options={tags}
-          selected={constraintDefinitionTags}
-          on:change={onDefinitionTagsInputChange}
-        />
-      </fieldset>
-    </svelte:fragment>
-  </Panel>
-
-  <CssGridGutter track={1} type="column" />
-
-  <ConstraintEditor
-    constraintDefinition={constraintDefinitionCode}
-    {referenceModelId}
-    readOnly={!hasCreateDefinitionCodePermission}
-    title="{mode === 'create' ? 'New' : 'Edit'} Constraint - Definition Editor"
-    {user}
-    on:didChangeModelContent={onDidChangeModelContent}
-    on:selectReferenceModel={onSelectReferenceModel}
-  />
-</CssGrid>
-
-<style>
-  .public-button {
-    column-gap: 0.3rem;
-    display: grid;
-    grid-template-columns: min-content min-content;
-  }
-
-  .definition-divider {
-    border-top: 1px solid var(--st-gray-20);
-    display: grid;
-    margin: 2rem 1rem;
-  }
-
-  .constraint-form-error {
-    border-color: var(--st-error-red);
-    color: var(--st-error-red);
-  }
-
-  .constraint-form-error-message {
-    color: var(--st-error-red);
-    margin: 0.25rem;
-  }
-</style>
+<AssociationForm
+  allMetadata={$constraints}
+  displayName="Constraint"
+  {hasCreateDefinitionCodePermission}
+  {hasWriteMetadataPermission}
+  initialDefinitionAuthor={initialConstraintDefinitionAuthor}
+  initialDefinitionCode={initialConstraintDefinitionCode}
+  initialDescription={initialConstraintDescription}
+  initialId={initialConstraintId}
+  initialName={initialConstraintName}
+  initialPublic={initialConstraintPublic}
+  initialDefinitionTags={initialConstraintDefinitionTags}
+  initialMetadataTags={initialConstraintMetadataTags}
+  initialOwner={initialConstraintOwner}
+  initialRevision={initialConstraintRevision}
+  {initialReferenceModelId}
+  {permissionError}
+  revisions={constraintRevisions}
+  {tags}
+  tsFiles={constraintsTsFiles}
+  {mode}
+  {user}
+  on:close={onClose}
+  on:createDefinition={onCreateNewConstraintDefinition}
+  on:createMetadata={onCreateConstraint}
+  on:updateDefinitionTags={onSaveConstraintDefinitionRevisionTags}
+  on:updateMetadata={onSaveConstraintMetadata}
+  on:selectRevision={onRevisionSelection}
+  on:selectReferenceModel={onSelectReferenceModel}
+/>
diff --git a/src/components/constraints/Constraints.svelte b/src/components/constraints/Constraints.svelte
index 8c90f81354..94f7d61cf5 100644
--- a/src/components/constraints/Constraints.svelte
+++ b/src/components/constraints/Constraints.svelte
@@ -13,6 +13,7 @@
   import { permissionHandler } from '../../utilities/permissionHandler';
   import { featurePermissions } from '../../utilities/permissions';
   import Input from '../form/Input.svelte';
+  import DefinitionEditor from '../ui/Association/DefinitionEditor.svelte';
   import CssGrid from '../ui/CssGrid.svelte';
   import CssGridGutter from '../ui/CssGridGutter.svelte';
   import DataGridActions from '../ui/DataGrid/DataGridActions.svelte';
@@ -20,7 +21,6 @@
   import SingleActionDataGrid from '../ui/DataGrid/SingleActionDataGrid.svelte';
   import Panel from '../ui/Panel.svelte';
   import SectionTitle from '../ui/SectionTitle.svelte';
-  import ConstraintEditor from './ConstraintEditor.svelte';
 
   export let user: User | null;
 
@@ -100,59 +100,57 @@
     const includesName = constraint.name.toLocaleLowerCase().includes(filterTextLowerCase);
     return includesId || includesName;
   });
-  $: hasPermission = featurePermissions.constraints.canRead(user);
+  $: hasPermission = featurePermissions.constraints.canCreate(user);
   $: if (selectedConstraint !== null) {
     const found = $constraints.findIndex(constraint => constraint.id === selectedConstraint?.id);
     if (found === -1) {
       selectedConstraint = null;
     }
   }
-  $: {
-    columnDefs = [
-      ...baseColumnDefs,
-      {
-        cellClass: 'action-cell-container',
-        cellRenderer: (params: ConstraintsCellRendererParams) => {
-          const actionsDiv = document.createElement('div');
-          actionsDiv.className = 'actions-cell';
-          new DataGridActions({
-            props: {
-              deleteCallback: params.deleteConstraint,
-              deleteTooltip: {
-                content: 'Delete Constraint',
-                placement: 'bottom',
-              },
-              editCallback: params.editConstraint,
-              editTooltip: {
-                content: 'Edit Constraint',
-                placement: 'bottom',
-              },
-              hasDeletePermission: params.data ? hasDeletePermission(user, params.data) : false,
-              hasDeletePermissionError:
-                params.data && !hasDeletePermission(user, params.data) && isConstraintInUse(params.data)
-                  ? 'Cannot delete constraint that is being used'
-                  : '',
-              hasEditPermission: params.data ? hasEditPermission(user, params.data) : false,
-              rowData: params.data,
+  $: columnDefs = [
+    ...baseColumnDefs,
+    {
+      cellClass: 'action-cell-container',
+      cellRenderer: (params: ConstraintsCellRendererParams) => {
+        const actionsDiv = document.createElement('div');
+        actionsDiv.className = 'actions-cell';
+        new DataGridActions({
+          props: {
+            deleteCallback: params.deleteConstraint,
+            deleteTooltip: {
+              content: 'Delete Constraint',
+              placement: 'bottom',
+            },
+            editCallback: params.editConstraint,
+            editTooltip: {
+              content: 'Edit Constraint',
+              placement: 'bottom',
             },
-            target: actionsDiv,
-          });
+            hasDeletePermission: params.data ? hasDeletePermission(user, params.data) : false,
+            hasDeletePermissionError:
+              params.data && !hasDeletePermission(user, params.data) && isConstraintInUse(params.data)
+                ? 'Cannot delete constraint that is being used'
+                : '',
+            hasEditPermission: params.data ? hasEditPermission(user, params.data) : false,
+            rowData: params.data,
+          },
+          target: actionsDiv,
+        });
 
-          return actionsDiv;
-        },
-        cellRendererParams: {
-          deleteConstraint,
-          editConstraint,
-        } as CellRendererParams,
-        headerName: '',
-        resizable: false,
-        sortable: false,
-        suppressAutoSize: true,
-        suppressSizeToFit: true,
-        width: 55,
+        return actionsDiv;
       },
-    ];
-  }
+      cellRendererParams: {
+        deleteConstraint,
+        editConstraint,
+      } as CellRendererParams,
+      headerName: '',
+      resizable: false,
+      sortable: false,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 55,
+    },
+  ];
 
   async function deleteConstraint(constraint: ConstraintMetadata) {
     const success = await effects.deleteConstraint(constraint, user);
@@ -195,7 +193,7 @@
     return featurePermissions.constraints.canDelete(user, constraint) && !isConstraintInUse(constraint);
   }
 
-  function hasEditPermission(_user: User | null, constraint: ConstraintMetadata) {
+  function hasEditPermission(user: User | null, constraint: ConstraintMetadata) {
     return featurePermissions.constraints.canUpdate(user, constraint);
   }
 
@@ -257,12 +255,11 @@
 
   <CssGridGutter track={1} type="column" />
 
-  <ConstraintEditor
-    constraintDefinition={selectedConstraint
+  <DefinitionEditor
+    definition={selectedConstraint
       ? selectedConstraint.versions[selectedConstraint.versions.length - 1].definition
       : 'No Constraint Selected'}
     readOnly={true}
     title="Constraint - Definition Editor (Read-only)"
-    {user}
   />
 </CssGrid>
diff --git a/src/components/modals/ManagePlanSchedulingConditionsModal.svelte b/src/components/modals/ManagePlanSchedulingConditionsModal.svelte
new file mode 100644
index 0000000000..3b19e22e6e
--- /dev/null
+++ b/src/components/modals/ManagePlanSchedulingConditionsModal.svelte
@@ -0,0 +1,351 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import { base } from '$app/paths';
+  import type { CellEditingStoppedEvent, ICellRendererParams, ValueGetterParams } from 'ag-grid-community';
+  import { createEventDispatcher } from 'svelte';
+  import { PlanStatusMessages } from '../../enums/planStatusMessages';
+  import { SearchParameters } from '../../enums/searchParameters';
+  import { plan, planReadOnly } from '../../stores/plan';
+  import {
+    allowedSchedulingConditionSpecs,
+    schedulingConditions,
+    schedulingPlanSpecification,
+  } from '../../stores/scheduling';
+  import type { User } from '../../types/app';
+  import type { DataGridColumnDef } from '../../types/data-grid';
+  import type {
+    SchedulingConditionMetadata,
+    SchedulingConditionPlanSpecInsertInput,
+    SchedulingConditionPlanSpecification,
+  } from '../../types/scheduling';
+  import effects from '../../utilities/effects';
+  import { permissionHandler } from '../../utilities/permissionHandler';
+  import { featurePermissions, isAdminRole } from '../../utilities/permissions';
+  import Input from '../form/Input.svelte';
+  import DataGrid from '../ui/DataGrid/DataGrid.svelte';
+  import DataGridActions from '../ui/DataGrid/DataGridActions.svelte';
+  import { tagsCellRenderer, tagsFilterValueGetter } from '../ui/DataGrid/DataGridTags';
+  import Modal from './Modal.svelte';
+  import ModalContent from './ModalContent.svelte';
+  import ModalFooter from './ModalFooter.svelte';
+  import ModalHeader from './ModalHeader.svelte';
+
+  export let user: User | null;
+
+  type CellRendererParams = {
+    viewCondition: (condition: SchedulingConditionMetadata) => void;
+  };
+  type SchedulingConditionCellRendererParams = ICellRendererParams<SchedulingConditionMetadata> & CellRendererParams;
+
+  const dispatch = createEventDispatcher();
+  const baseColumnDefs: DataGridColumnDef<SchedulingConditionMetadata>[] = [
+    {
+      field: 'id',
+      filter: 'number',
+      headerName: 'ID',
+      resizable: true,
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 60,
+    },
+    { field: 'name', filter: 'text', headerName: 'Name', minWidth: 80, resizable: true, sortable: true },
+    {
+      field: 'owner',
+      filter: 'string',
+      headerName: 'Owner',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 80,
+    },
+    {
+      field: 'updated_by',
+      filter: 'string',
+      headerName: 'Updated By',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 120,
+    },
+    {
+      field: 'versions',
+      filter: 'string',
+      headerName: 'Latest',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      valueGetter: (params: ValueGetterParams<SchedulingConditionMetadata>) => {
+        return params?.data?.versions[params?.data?.versions.length - 1].revision;
+      },
+      width: 80,
+    },
+    {
+      autoHeight: true,
+      cellRenderer: tagsCellRenderer,
+      field: 'tags',
+      filter: 'text',
+      filterValueGetter: tagsFilterValueGetter,
+      headerName: 'Tags',
+      resizable: true,
+      sortable: false,
+      width: 220,
+      wrapText: true,
+    },
+  ];
+  const permissionError = 'You do not have permission to add this constraint.';
+
+  let columnDefs = baseColumnDefs;
+
+  let dataGrid: DataGrid<SchedulingConditionMetadata> | undefined = undefined;
+  let filterText: string = '';
+  let filteredConditions: SchedulingConditionMetadata[] = [];
+  let hasCreatePermission: boolean = false;
+  let hasEditSpecPermission: boolean = false;
+  let selectedConditions: Record<string, boolean> = {};
+
+  $: filteredConditions = $schedulingConditions
+    // TODO: remove this after db merge as it becomes redundant
+    .filter(({ owner, public: isPublic }) => {
+      if (!isPublic && !isAdminRole(user?.activeRole)) {
+        return owner === user?.id;
+      }
+      return true;
+    })
+    .filter(condition => {
+      const filterTextLowerCase = filterText.toLowerCase();
+      const includesId = `${condition.id}`.includes(filterTextLowerCase);
+      const includesName = condition.name.toLocaleLowerCase().includes(filterTextLowerCase);
+      return includesId || includesName;
+    });
+  $: selectedConditions = $allowedSchedulingConditionSpecs.reduce(
+    (prevBooleanMap: Record<string, boolean>, schedulingConditionPlanSpec: SchedulingConditionPlanSpecification) => {
+      return {
+        ...prevBooleanMap,
+        [schedulingConditionPlanSpec.condition_id]: true,
+      };
+    },
+    {},
+  );
+  $: hasCreatePermission = featurePermissions.schedulingConditions.canCreate(user);
+  $: hasEditSpecPermission = $plan ? featurePermissions.schedulingConditionsPlanSpec.canUpdate(user, $plan) : false;
+  $: {
+    columnDefs = [
+      ...baseColumnDefs,
+      {
+        cellClass: 'action-cell-container',
+        cellRenderer: (params: SchedulingConditionCellRendererParams) => {
+          const actionsDiv = document.createElement('div');
+          actionsDiv.className = 'actions-cell';
+          new DataGridActions({
+            props: {
+              rowData: params.data,
+              viewCallback: params.viewCondition,
+              viewTooltip: {
+                content: 'View Condition',
+                placement: 'bottom',
+              },
+            },
+            target: actionsDiv,
+          });
+
+          return actionsDiv;
+        },
+        cellRendererParams: {
+          viewCondition,
+        } as CellRendererParams,
+        headerName: '',
+        resizable: false,
+        sortable: false,
+        suppressAutoSize: true,
+        suppressSizeToFit: true,
+        width: 20,
+      },
+      {
+        cellDataType: 'boolean',
+        editable: hasEditSpecPermission,
+        headerName: '',
+        suppressAutoSize: true,
+        suppressSizeToFit: true,
+        valueGetter: (params: ValueGetterParams<SchedulingConditionMetadata>) => {
+          const { data } = params;
+          if (data) {
+            return !!selectedConditions[data.id];
+          }
+          return false;
+        },
+        width: 35,
+      },
+    ];
+  }
+  $: if (selectedConditions) {
+    dataGrid?.redrawRows();
+  }
+
+  function viewCondition({ id }: Pick<SchedulingConditionMetadata, 'id'>) {
+    const condition = $schedulingConditions.find(c => c.id === id);
+    window.open(
+      `${base}/scheduling/conditions/edit/${condition?.id}?${SearchParameters.REVISION}=${
+        condition?.versions[condition?.versions.length - 1].revision
+      }&${SearchParameters.MODEL_ID}=${$plan?.model.id}`,
+    );
+  }
+
+  function onToggleCondition(event: CustomEvent<CellEditingStoppedEvent<SchedulingConditionMetadata, boolean>>) {
+    const {
+      detail: { data, newValue },
+    } = event;
+
+    if (data) {
+      selectedConditions = {
+        ...selectedConditions,
+        [data.id]: newValue,
+      };
+    }
+  }
+
+  async function onUpdateCondition(selectedConditions: Record<number, boolean>) {
+    if ($plan && $schedulingPlanSpecification) {
+      const conditionPlanSpecUpdates: {
+        conditionPlanSpecIdsToDelete: number[];
+        conditionPlanSpecsToAdd: SchedulingConditionPlanSpecInsertInput[];
+      } = Object.keys(selectedConditions).reduce(
+        (
+          prevConditionPlanSpecUpdates: {
+            conditionPlanSpecIdsToDelete: number[];
+            conditionPlanSpecsToAdd: SchedulingConditionPlanSpecInsertInput[];
+          },
+          selectedConditionId: string,
+        ) => {
+          const conditionId = parseInt(selectedConditionId);
+          const isSelected = selectedConditions[conditionId];
+          const conditionPlanSpec = $allowedSchedulingConditionSpecs[conditionId];
+
+          if (isSelected && $schedulingPlanSpecification !== null) {
+            if (!conditionPlanSpec || conditionPlanSpec.condition_metadata?.owner === user?.id) {
+              return {
+                ...prevConditionPlanSpecUpdates,
+                conditionPlanSpecsToAdd: [
+                  ...prevConditionPlanSpecUpdates.conditionPlanSpecsToAdd,
+                  {
+                    condition_id: conditionId,
+                    condition_revision: null,
+                    enabled: true,
+                    specification_id: $schedulingPlanSpecification.id,
+                  } as SchedulingConditionPlanSpecInsertInput,
+                ],
+              };
+            }
+            return prevConditionPlanSpecUpdates;
+          } else {
+            return {
+              ...prevConditionPlanSpecUpdates,
+              conditionPlanSpecIdsToDelete: [...prevConditionPlanSpecUpdates.conditionPlanSpecIdsToDelete, conditionId],
+            };
+          }
+        },
+        {
+          conditionPlanSpecIdsToDelete: [],
+          conditionPlanSpecsToAdd: [],
+        },
+      );
+      await effects.updateSchedulingConditionPlanSpecifications(
+        $plan,
+        $schedulingPlanSpecification.id,
+        conditionPlanSpecUpdates.conditionPlanSpecsToAdd,
+        conditionPlanSpecUpdates.conditionPlanSpecIdsToDelete,
+        user,
+      );
+      dispatch('close');
+    }
+  }
+</script>
+
+<Modal height={500} width={750}>
+  <ModalHeader on:close>Manage Scheduling Conditions</ModalHeader>
+  <ModalContent style="padding:0">
+    <div class="conditions-modal-container">
+      <div class="conditions-modal-filter-container">
+        <div class="conditions-modal-title">Scheduling Conditions</div>
+        <Input>
+          <input bind:value={filterText} class="st-input" placeholder="Filter conditions" style="width: 100%;" />
+        </Input>
+        <button
+          class="st-button secondary ellipsis"
+          name="new-scheduling-condition"
+          use:permissionHandler={{
+            hasPermission: hasCreatePermission,
+            permissionError,
+          }}
+          on:click={() =>
+            window.open(`${base}/scheduling/conditions/new?${SearchParameters.MODEL_ID}=${$plan?.model_id}`)}
+        >
+          New
+        </button>
+      </div>
+      <hr />
+      <div class="conditions-modal-table-container">
+        {#if filteredConditions.length}
+          <DataGrid
+            bind:this={dataGrid}
+            {columnDefs}
+            rowData={filteredConditions}
+            on:cellEditingStopped={onToggleCondition}
+          />
+        {:else}
+          <div class="p1 st-typography-label">No Scheduling Conditions Found</div>
+        {/if}
+      </div>
+    </div>
+  </ModalContent>
+  <ModalFooter>
+    <button class="st-button secondary" on:click={() => dispatch('close')}> Cancel </button>
+    <button
+      class="st-button"
+      on:click={() => onUpdateCondition(selectedConditions)}
+      use:permissionHandler={{
+        hasPermission: hasEditSpecPermission && !$planReadOnly,
+        permissionError: $planReadOnly
+          ? PlanStatusMessages.READ_ONLY
+          : 'You do not have permission to update the scheduling conditions on this plan.',
+      }}
+    >
+      Update
+    </button>
+  </ModalFooter>
+</Modal>
+
+<style>
+  .conditions-modal-container {
+    display: grid;
+    grid-template-rows: min-content min-content auto;
+    height: 100%;
+    row-gap: 0.5rem;
+  }
+
+  .conditions-modal-container hr {
+    border: none;
+    border-top: 1px solid #e0e0e0;
+    margin: 0 1rem;
+    width: auto;
+  }
+
+  .conditions-modal-filter-container {
+    align-items: center;
+    column-gap: 0.25rem;
+    display: grid;
+    grid-template-columns: min-content auto min-content;
+    margin: 0.5rem 1rem 0;
+  }
+
+  .conditions-modal-title {
+    font-weight: bold;
+  }
+
+  .conditions-modal-table-container {
+    height: 100%;
+    padding: 0 1rem 0.5rem;
+    width: 100%;
+  }
+</style>
diff --git a/src/components/modals/ManagePlanSchedulingGoalsModal.svelte b/src/components/modals/ManagePlanSchedulingGoalsModal.svelte
new file mode 100644
index 0000000000..6aa2a229f9
--- /dev/null
+++ b/src/components/modals/ManagePlanSchedulingGoalsModal.svelte
@@ -0,0 +1,341 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import { base } from '$app/paths';
+  import type { CellEditingStoppedEvent, ICellRendererParams, ValueGetterParams } from 'ag-grid-community';
+  import { createEventDispatcher } from 'svelte';
+  import { PlanStatusMessages } from '../../enums/planStatusMessages';
+  import { SearchParameters } from '../../enums/searchParameters';
+  import { plan, planReadOnly } from '../../stores/plan';
+  import { allowedSchedulingGoalSpecs, schedulingGoals, schedulingPlanSpecification } from '../../stores/scheduling';
+  import type { User } from '../../types/app';
+  import type { DataGridColumnDef } from '../../types/data-grid';
+  import type {
+    SchedulingGoalMetadata,
+    SchedulingGoalPlanSpecInsertInput,
+    SchedulingGoalPlanSpecification,
+  } from '../../types/scheduling';
+  import effects from '../../utilities/effects';
+  import { permissionHandler } from '../../utilities/permissionHandler';
+  import { featurePermissions, isAdminRole } from '../../utilities/permissions';
+  import Input from '../form/Input.svelte';
+  import DataGrid from '../ui/DataGrid/DataGrid.svelte';
+  import DataGridActions from '../ui/DataGrid/DataGridActions.svelte';
+  import { tagsCellRenderer, tagsFilterValueGetter } from '../ui/DataGrid/DataGridTags';
+  import Modal from './Modal.svelte';
+  import ModalContent from './ModalContent.svelte';
+  import ModalFooter from './ModalFooter.svelte';
+  import ModalHeader from './ModalHeader.svelte';
+
+  export let user: User | null;
+
+  type CellRendererParams = {
+    viewGoal: (goal: SchedulingGoalMetadata) => void;
+  };
+  type SchedulingGoalCellRendererParams = ICellRendererParams<SchedulingGoalMetadata> & CellRendererParams;
+
+  const dispatch = createEventDispatcher();
+  const baseColumnDefs: DataGridColumnDef<SchedulingGoalMetadata>[] = [
+    {
+      field: 'id',
+      filter: 'number',
+      headerName: 'ID',
+      resizable: true,
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 60,
+    },
+    { field: 'name', filter: 'text', headerName: 'Name', minWidth: 80, resizable: true, sortable: true },
+    {
+      field: 'owner',
+      filter: 'string',
+      headerName: 'Owner',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 80,
+    },
+    {
+      field: 'updated_by',
+      filter: 'string',
+      headerName: 'Updated By',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 120,
+    },
+    {
+      field: 'versions',
+      filter: 'string',
+      headerName: 'Latest',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      valueGetter: (params: ValueGetterParams<SchedulingGoalMetadata>) => {
+        return params?.data?.versions[params?.data?.versions.length - 1].revision;
+      },
+      width: 80,
+    },
+    {
+      autoHeight: true,
+      cellRenderer: tagsCellRenderer,
+      field: 'tags',
+      filter: 'text',
+      filterValueGetter: tagsFilterValueGetter,
+      headerName: 'Tags',
+      resizable: true,
+      sortable: false,
+      width: 220,
+      wrapText: true,
+    },
+  ];
+  const permissionError = 'You do not have permission to add this constraint.';
+
+  let columnDefs = baseColumnDefs;
+
+  let dataGrid: DataGrid<SchedulingGoalMetadata> | undefined = undefined;
+  let filterText: string = '';
+  let filteredGoals: SchedulingGoalMetadata[] = [];
+  let hasCreatePermission: boolean = false;
+  let hasEditSpecPermission: boolean = false;
+  let selectedGoals: Record<string, boolean> = {};
+
+  $: filteredGoals = $schedulingGoals
+    // TODO: remove this after db merge as it becomes redundant
+    .filter(({ owner, public: isPublic }) => {
+      if (!isPublic && !isAdminRole(user?.activeRole)) {
+        return owner === user?.id;
+      }
+      return true;
+    })
+    .filter(goal => {
+      const filterTextLowerCase = filterText.toLowerCase();
+      const includesId = `${goal.id}`.includes(filterTextLowerCase);
+      const includesName = goal.name.toLocaleLowerCase().includes(filterTextLowerCase);
+      return includesId || includesName;
+    });
+  $: selectedGoals = $allowedSchedulingGoalSpecs.reduce(
+    (prevBooleanMap: Record<string, boolean>, schedulingGoalPlanSpec: SchedulingGoalPlanSpecification) => {
+      return {
+        ...prevBooleanMap,
+        [schedulingGoalPlanSpec.goal_id]: true,
+      };
+    },
+    {},
+  );
+  $: hasCreatePermission = featurePermissions.schedulingGoals.canCreate(user);
+  $: hasEditSpecPermission = $plan ? featurePermissions.schedulingGoalsPlanSpec.canUpdate(user, $plan) : false;
+  $: {
+    columnDefs = [
+      ...baseColumnDefs,
+      {
+        cellClass: 'action-cell-container',
+        cellRenderer: (params: SchedulingGoalCellRendererParams) => {
+          const actionsDiv = document.createElement('div');
+          actionsDiv.className = 'actions-cell';
+          new DataGridActions({
+            props: {
+              rowData: params.data,
+              viewCallback: params.viewGoal,
+              viewTooltip: {
+                content: 'View Goal',
+                placement: 'bottom',
+              },
+            },
+            target: actionsDiv,
+          });
+
+          return actionsDiv;
+        },
+        cellRendererParams: {
+          viewGoal,
+        } as CellRendererParams,
+        headerName: '',
+        resizable: false,
+        sortable: false,
+        suppressAutoSize: true,
+        suppressSizeToFit: true,
+        width: 20,
+      },
+      {
+        cellDataType: 'boolean',
+        editable: hasEditSpecPermission,
+        headerName: '',
+        suppressAutoSize: true,
+        suppressSizeToFit: true,
+        valueGetter: (params: ValueGetterParams<SchedulingGoalMetadata>) => {
+          const { data } = params;
+          if (data) {
+            return !!selectedGoals[data.id];
+          }
+          return false;
+        },
+        width: 35,
+      },
+    ];
+  }
+  $: if (selectedGoals) {
+    dataGrid?.redrawRows();
+  }
+
+  function viewGoal({ id }: Pick<SchedulingGoalMetadata, 'id'>) {
+    const goal = $schedulingGoals.find(c => c.id === id);
+    window.open(
+      `${base}/scheduling/goals/edit/${goal?.id}?${SearchParameters.REVISION}=${
+        goal?.versions[goal?.versions.length - 1].revision
+      }&${SearchParameters.MODEL_ID}=${$plan?.model.id}`,
+    );
+  }
+
+  function onToggleGoal(event: CustomEvent<CellEditingStoppedEvent<SchedulingGoalMetadata, boolean>>) {
+    const {
+      detail: { data, newValue },
+    } = event;
+
+    if (data) {
+      selectedGoals = {
+        ...selectedGoals,
+        [data.id]: newValue,
+      };
+    }
+  }
+
+  async function onUpdateGoal(selectedGoals: Record<number, boolean>) {
+    if ($plan && $schedulingPlanSpecification) {
+      const goalPlanSpecUpdates: {
+        goalPlanSpecIdsToDelete: number[];
+        goalPlanSpecsToAdd: SchedulingGoalPlanSpecInsertInput[];
+      } = Object.keys(selectedGoals).reduce(
+        (
+          prevGoalPlanSpecUpdates: {
+            goalPlanSpecIdsToDelete: number[];
+            goalPlanSpecsToAdd: SchedulingGoalPlanSpecInsertInput[];
+          },
+          selectedGoalId: string,
+        ) => {
+          const goalId = parseInt(selectedGoalId);
+          const isSelected = selectedGoals[goalId];
+          const goalPlanSpec = $allowedSchedulingGoalSpecs[goalId];
+
+          if (isSelected && $schedulingPlanSpecification !== null) {
+            if (!goalPlanSpec || goalPlanSpec.goal_metadata?.owner === user?.id) {
+              return {
+                ...prevGoalPlanSpecUpdates,
+                goalPlanSpecsToAdd: [
+                  ...prevGoalPlanSpecUpdates.goalPlanSpecsToAdd,
+                  {
+                    enabled: true,
+                    goal_id: goalId,
+                    goal_revision: null,
+                    specification_id: $schedulingPlanSpecification.id,
+                  } as SchedulingGoalPlanSpecInsertInput,
+                ],
+              };
+            }
+            return prevGoalPlanSpecUpdates;
+          } else {
+            return {
+              ...prevGoalPlanSpecUpdates,
+              goalPlanSpecIdsToDelete: [...prevGoalPlanSpecUpdates.goalPlanSpecIdsToDelete, goalId],
+            };
+          }
+        },
+        {
+          goalPlanSpecIdsToDelete: [],
+          goalPlanSpecsToAdd: [],
+        },
+      );
+      await effects.updateSchedulingGoalPlanSpecifications(
+        $plan,
+        $schedulingPlanSpecification.id,
+        goalPlanSpecUpdates.goalPlanSpecsToAdd,
+        goalPlanSpecUpdates.goalPlanSpecIdsToDelete,
+        user,
+      );
+      dispatch('close');
+    }
+  }
+</script>
+
+<Modal height={500} width={750}>
+  <ModalHeader on:close>Manage Scheduling Goals</ModalHeader>
+  <ModalContent style="padding:0">
+    <div class="goals-modal-container">
+      <div class="goals-modal-filter-container">
+        <div class="goals-modal-title">Scheduling Goals</div>
+        <Input>
+          <input bind:value={filterText} class="st-input" placeholder="Filter goals" style="width: 100%;" />
+        </Input>
+        <button
+          class="st-button secondary ellipsis"
+          name="new-scheduling-goal"
+          use:permissionHandler={{
+            hasPermission: hasCreatePermission,
+            permissionError,
+          }}
+          on:click={() => window.open(`${base}/scheduling/goals/new?${SearchParameters.MODEL_ID}=${$plan?.model_id}`)}
+        >
+          New
+        </button>
+      </div>
+      <hr />
+      <div class="goals-modal-table-container">
+        {#if filteredGoals.length}
+          <DataGrid bind:this={dataGrid} {columnDefs} rowData={filteredGoals} on:cellEditingStopped={onToggleGoal} />
+        {:else}
+          <div class="p1 st-typography-label">No Scheduling Goals Found</div>
+        {/if}
+      </div>
+    </div>
+  </ModalContent>
+  <ModalFooter>
+    <button class="st-button secondary" on:click={() => dispatch('close')}> Cancel </button>
+    <button
+      class="st-button"
+      on:click={() => onUpdateGoal(selectedGoals)}
+      use:permissionHandler={{
+        hasPermission: hasEditSpecPermission && !$planReadOnly,
+        permissionError: $planReadOnly
+          ? PlanStatusMessages.READ_ONLY
+          : 'You do not have permission to update the scheduling goals on this plan.',
+      }}
+    >
+      Update
+    </button>
+  </ModalFooter>
+</Modal>
+
+<style>
+  .goals-modal-container {
+    display: grid;
+    grid-template-rows: min-content min-content auto;
+    height: 100%;
+    row-gap: 0.5rem;
+  }
+
+  .goals-modal-container hr {
+    border: none;
+    border-top: 1px solid #e0e0e0;
+    margin: 0 1rem;
+    width: auto;
+  }
+
+  .goals-modal-filter-container {
+    align-items: center;
+    column-gap: 0.25rem;
+    display: grid;
+    grid-template-columns: min-content auto min-content;
+    margin: 0.5rem 1rem 0;
+  }
+
+  .goals-modal-title {
+    font-weight: bold;
+  }
+
+  .goals-modal-table-container {
+    height: 100%;
+    padding: 0 1rem 0.5rem;
+    width: 100%;
+  }
+</style>
diff --git a/src/components/scheduling/Scheduling.svelte b/src/components/scheduling/Scheduling.svelte
index 2c0d1aff4e..7a482d417e 100644
--- a/src/components/scheduling/Scheduling.svelte
+++ b/src/components/scheduling/Scheduling.svelte
@@ -1,68 +1,78 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
-  import { schedulingColumns, schedulingConditionsAll, schedulingGoalsAll } from '../../stores/scheduling';
+  import {
+    schedulingColumns,
+    schedulingConditionResponses,
+    schedulingConditions,
+    schedulingGoalResponses,
+    schedulingGoals,
+  } from '../../stores/scheduling';
   import type { User } from '../../types/app';
   import type { DataGridRowSelection } from '../../types/data-grid';
-  import type { PlanSchedulingSpec } from '../../types/plan';
-  import type { SchedulingCondition, SchedulingGoal, SchedulingGoalSlim } from '../../types/scheduling';
+  import type { SchedulingConditionMetadata, SchedulingGoalMetadata } from '../../types/scheduling';
   import effects from '../../utilities/effects';
+  import { isAdminRole } from '../../utilities/permissions';
+  import DefinitionEditor from '../ui/Association/DefinitionEditor.svelte';
   import CssGrid from '../ui/CssGrid.svelte';
   import CssGridGutter from '../ui/CssGridGutter.svelte';
-  import SchedulingEditor from './SchedulingEditor.svelte';
   import SchedulingConditions from './conditions/SchedulingConditions.svelte';
   import SchedulingGoals from './goals/SchedulingGoals.svelte';
 
-  export let plans: PlanSchedulingSpec[] | null;
   export let user: User | null;
 
-  let selectedCondition: SchedulingCondition | null = null;
-  let selectedGoal: SchedulingGoal | null = null;
-  let selectedItem: SchedulingCondition | SchedulingGoal | null = null;
   let editorTitle: string = 'Scheduling';
 
+  let allowedSchedulingConditions: SchedulingConditionMetadata[] = [];
+  let allowedSchedulingGoals: SchedulingGoalMetadata[] = [];
+  let selectedCondition: SchedulingConditionMetadata | null = null;
+  let selectedGoal: SchedulingGoalMetadata | null = null;
+  let selectedItem: SchedulingConditionMetadata | SchedulingGoalMetadata | null = null;
+
+  // TODO: remove this after db merge as it becomes redundant
+  $: allowedSchedulingConditions = $schedulingConditions.filter(({ owner, public: isPublic }) => {
+    if (!isPublic && !isAdminRole(user?.activeRole)) {
+      return owner === user?.id;
+    }
+    return true;
+  });
+  // TODO: remove this after db merge as it becomes redundant
+  $: allowedSchedulingGoals = $schedulingGoals.filter(({ owner, public: isPublic }) => {
+    if (!isPublic && !isAdminRole(user?.activeRole)) {
+      return owner === user?.id;
+    }
+    return true;
+  });
   $: if (selectedCondition !== null) {
-    const found = $schedulingConditionsAll.findIndex(condition => condition.id === selectedCondition?.id);
+    const found = allowedSchedulingConditions.findIndex(condition => condition.id === selectedCondition?.id);
     if (found === -1) {
       selectedCondition = null;
     }
   }
 
   $: if (selectedGoal !== null) {
-    const found = $schedulingGoalsAll.findIndex(goal => goal.id === selectedGoal?.id);
+    const found = allowedSchedulingGoals.findIndex(goal => goal.id === selectedGoal?.id);
     if (found === -1) {
       selectedGoal = null;
     }
   }
 
-  async function deleteCondition(condition: SchedulingCondition) {
-    const { scheduling_specification_conditions } = condition;
-    const specification_id = scheduling_specification_conditions[0].specification_id;
-    const plan = plans?.find(plan => plan.scheduling_specification?.id === specification_id);
+  async function deleteCondition(condition: SchedulingConditionMetadata) {
+    const success = await effects.deleteSchedulingCondition(condition, user);
 
-    if (plan) {
-      const success = await effects.deleteSchedulingCondition(condition, plan, user);
-
-      if (success) {
-        schedulingConditionsAll.filterValueById(condition.id);
+    if (success) {
+      schedulingConditionResponses.filterValueById(condition.id);
 
-        if (condition.id === selectedCondition?.id) {
-          selectedCondition = null;
-        }
+      if (condition.id === selectedCondition?.id) {
+        selectedCondition = null;
       }
     }
   }
 
-  async function deleteGoal(goal: SchedulingGoalSlim) {
-    const { scheduling_specification_goal } = goal;
-    let plan = null;
-    if (scheduling_specification_goal) {
-      const specification_id = scheduling_specification_goal.specification_id;
-      plan = plans?.find(plan => plan.scheduling_specification?.id === specification_id) ?? null;
-    }
-    const success = await effects.deleteSchedulingGoal(goal, plan, user);
+  async function deleteGoal(goal: SchedulingGoalMetadata) {
+    const success = await effects.deleteSchedulingGoal(goal, user);
     if (success) {
-      schedulingGoalsAll.filterValueById(goal.id);
+      schedulingGoalResponses.filterValueById(goal.id);
 
       if (goal.id === selectedGoal?.id) {
         selectedGoal = null;
@@ -72,7 +82,7 @@
 
   function deleteConditionContext(event: CustomEvent<number>) {
     const id = event.detail;
-    const condition = $schedulingConditionsAll.find(s => s.id === id);
+    const condition = allowedSchedulingConditions.find(s => s.id === id);
     if (condition) {
       deleteCondition(condition);
     }
@@ -80,13 +90,13 @@
 
   function deleteGoalContext(event: CustomEvent<number>) {
     const id = event.detail;
-    const goal = $schedulingGoalsAll.find(s => s.id === id);
+    const goal = allowedSchedulingGoals.find(s => s.id === id);
     if (goal) {
       deleteGoal(goal);
     }
   }
 
-  function selectCondition(condition: SchedulingCondition) {
+  function selectCondition(condition: SchedulingConditionMetadata) {
     selectedCondition = condition;
     selectedItem = condition;
     selectedGoal = null;
@@ -94,7 +104,7 @@
     editorTitle = 'Scheduling Condition - Definition Editor (Read-only)';
   }
 
-  function selectGoal(goal: SchedulingGoal) {
+  function selectGoal(goal: SchedulingGoalMetadata) {
     selectedGoal = goal;
     selectedItem = goal;
     selectedCondition = null;
@@ -102,7 +112,7 @@
     editorTitle = 'Scheduling Goal - Definition Editor (Read-only)';
   }
 
-  function toggleCondition(event: CustomEvent<DataGridRowSelection<SchedulingCondition>>) {
+  function toggleCondition(event: CustomEvent<DataGridRowSelection<SchedulingConditionMetadata>>) {
     const {
       detail: { data: clickedCondition, isSelected },
     } = event;
@@ -112,7 +122,7 @@
     }
   }
 
-  function toggleGoal(event: CustomEvent<DataGridRowSelection<SchedulingGoal>>) {
+  function toggleGoal(event: CustomEvent<DataGridRowSelection<SchedulingGoalMetadata>>) {
     const {
       detail: { data: clickedGoal, isSelected },
     } = event;
@@ -126,18 +136,16 @@
 <CssGrid bind:columns={$schedulingColumns}>
   <CssGrid rows="1fr 3px 1fr">
     <SchedulingGoals
-      {plans}
       {selectedGoal}
-      schedulingGoals={$schedulingGoalsAll}
+      schedulingGoals={allowedSchedulingGoals}
       {user}
       on:deleteGoal={deleteGoalContext}
       on:rowSelected={toggleGoal}
     />
     <CssGridGutter track={1} type="row" />
     <SchedulingConditions
-      {plans}
       {selectedCondition}
-      schedulingConditions={$schedulingConditionsAll}
+      schedulingConditions={allowedSchedulingConditions}
       {user}
       on:deleteCondition={deleteConditionContext}
       on:rowSelected={toggleCondition}
@@ -146,11 +154,11 @@
 
   <CssGridGutter track={1} type="column" />
 
-  <SchedulingEditor
-    scheduleItemDefinition={selectedItem?.definition ?? 'No Scheduling Goal or Condition Selected'}
-    scheduleItemModelId={selectedItem?.model_id}
+  <DefinitionEditor
+    definition={selectedItem
+      ? selectedItem?.versions[selectedItem.versions.length - 1].definition
+      : 'No Scheduling Goal or Condition Selected'}
     readOnly={true}
     title={editorTitle}
-    {user}
   />
 </CssGrid>
diff --git a/src/components/scheduling/SchedulingConditionsPanel.svelte b/src/components/scheduling/SchedulingConditionsPanel.svelte
index 3d864ca66b..2ac5c0a438 100644
--- a/src/components/scheduling/SchedulingConditionsPanel.svelte
+++ b/src/components/scheduling/SchedulingConditionsPanel.svelte
@@ -1,16 +1,20 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
-  import { base } from '$app/paths';
   import { afterUpdate, beforeUpdate } from 'svelte';
   import { PlanStatusMessages } from '../../enums/planStatusMessages';
   import { plan, planReadOnly } from '../../stores/plan';
-  import { schedulingSpecConditions, selectedSpecId } from '../../stores/scheduling';
+  import {
+    allowedSchedulingConditionSpecs,
+    schedulingConditionSpecifications,
+    schedulingConditionsMap,
+  } from '../../stores/scheduling';
   import type { User } from '../../types/app';
-  import type { SchedulingSpecCondition } from '../../types/scheduling';
+  import type { SchedulingConditionPlanSpecification } from '../../types/scheduling';
   import type { ViewGridSection } from '../../types/view';
+  import effects from '../../utilities/effects';
   import { permissionHandler } from '../../utilities/permissionHandler';
-  import { featurePermissions } from '../../utilities/permissions';
+  import { featurePermissions, isAdminRole } from '../../utilities/permissions';
   import CollapsibleListControls from '../CollapsibleListControls.svelte';
   import GridMenu from '../menus/GridMenu.svelte';
   import Panel from '../ui/Panel.svelte';
@@ -21,22 +25,51 @@
 
   let activeElement: HTMLElement;
   let conditionsFilterText: string = '';
-  let hasCreatePermission: boolean = false;
-  let hasDeletePermission: boolean = false;
-  let hasEditPermission: boolean = false;
-  let filteredSchedulingSpecConditions: SchedulingSpecCondition[] = [];
+  let filteredSchedulingConditionSpecs: SchedulingConditionPlanSpecification[] = [];
+  let numOfPrivateConditions: number = 0;
+  let visibleSchedulingConditionSpecs: SchedulingConditionPlanSpecification[] = [];
 
-  $: if ($plan) {
-    hasCreatePermission = featurePermissions.schedulingConditions.canCreate(user, $plan) && !$planReadOnly;
-    hasDeletePermission = featurePermissions.schedulingConditions.canDelete(user, $plan) && !$planReadOnly;
-    hasEditPermission = featurePermissions.schedulingConditions.canUpdate(user, $plan) && !$planReadOnly;
-  }
-
-  $: filteredSchedulingSpecConditions = $schedulingSpecConditions.filter(spec => {
+  // TODO: remove this after db merge as it becomes redundant
+  $: visibleSchedulingConditionSpecs = $allowedSchedulingConditionSpecs.filter(
+    ({ condition_metadata: conditionMetadata }) => {
+      if (conditionMetadata) {
+        const { public: isPublic, owner } = conditionMetadata;
+        if (!isPublic && !isAdminRole(user?.activeRole)) {
+          return owner === user?.id;
+        }
+        return true;
+      }
+      return false;
+    },
+  );
+  $: filteredSchedulingConditionSpecs = visibleSchedulingConditionSpecs.filter(spec => {
     const filterTextLowerCase = conditionsFilterText.toLowerCase();
-    const includesName = spec.condition.name.toLocaleLowerCase().includes(filterTextLowerCase);
+    const includesName = spec.condition_metadata?.name.toLocaleLowerCase().includes(filterTextLowerCase);
     return includesName;
   });
+  $: numOfPrivateConditions = $schedulingConditionSpecifications.length - visibleSchedulingConditionSpecs.length;
+
+  function onManageConditions() {
+    effects.managePlanSchedulingConditions(user);
+  }
+
+  async function onUpdateCondition(event: CustomEvent<SchedulingConditionPlanSpecification>) {
+    const {
+      detail: { condition_metadata, specification_id, ...conditionPlanSpec },
+    } = event;
+
+    if ($plan) {
+      await effects.updateSchedulingConditionPlanSpecification(
+        $plan,
+        specification_id,
+        {
+          ...conditionPlanSpec,
+          specification_id,
+        },
+        user,
+      );
+    }
+  }
 
   // Manually keep focus as scheduling condition elements are re-ordered.
   // Svelte currently does not retain focus as elements are moved, even when keyed.
@@ -62,44 +95,63 @@
       placeholder="Filter scheduling conditions"
       on:input={event => (conditionsFilterText = event.detail.value)}
     >
-      <button
-        slot="right"
-        name="new-scheduling-condition"
-        class="st-button secondary"
-        on:click={() =>
-          window.open(
-            `${base}/scheduling/conditions/new?modelId=${$plan?.model.id}&&specId=${$selectedSpecId}`,
-            '_blank',
-          )}
-        use:permissionHandler={{
-          hasPermission: hasCreatePermission,
-          permissionError: $planReadOnly
-            ? PlanStatusMessages.READ_ONLY
-            : 'You do not have permission to create scheduling conditions for this plan.',
-        }}
-      >
-        New
-      </button>
+      <svelte:fragment slot="right">
+        <button
+          name="manage-conditions"
+          class="st-button secondary"
+          use:permissionHandler={{
+            hasPermission: $plan ? featurePermissions.schedulingConditions.canCreate(user) && !$planReadOnly : false,
+            permissionError: $planReadOnly
+              ? PlanStatusMessages.READ_ONLY
+              : 'You do not have permission to update scheduling conditions',
+          }}
+          on:click|stopPropagation={onManageConditions}
+        >
+          Manage Conditions
+        </button>
+      </svelte:fragment>
     </CollapsibleListControls>
     <div class="pt-2">
-      {#if !filteredSchedulingSpecConditions.length}
+      {#if !filteredSchedulingConditionSpecs.length}
         <div class="pt-1 st-typography-label">No scheduling conditions found</div>
+        <div class="private-label">
+          {#if numOfPrivateConditions > 0}
+            {numOfPrivateConditions} scheduling condition{numOfPrivateConditions !== 1 ? 's' : ''}
+            {numOfPrivateConditions > 1 ? 'are' : 'is'} private and not shown
+          {/if}
+        </div>
       {:else}
-        {#each filteredSchedulingSpecConditions as specCondition (specCondition.condition.id)}
-          <SchedulingCondition
-            condition={specCondition.condition}
-            enabled={specCondition.enabled}
-            {hasDeletePermission}
-            {hasEditPermission}
-            plan={$plan}
-            specificationId={specCondition.specification_id}
-            permissionError={$planReadOnly
-              ? PlanStatusMessages.READ_ONLY
-              : 'You do not have permission to edit scheduling conditions for this plan.'}
-            {user}
-          />
+        <div class="private-label">
+          {#if numOfPrivateConditions > 0}
+            {numOfPrivateConditions} scheduling condition{numOfPrivateConditions !== 1 ? 's' : ''}
+            {numOfPrivateConditions > 1 ? 'are' : 'is'} private and not shown
+          {/if}
+        </div>
+        {#each filteredSchedulingConditionSpecs as specCondition (specCondition.condition_id)}
+          {#if $schedulingConditionsMap[specCondition.condition_id]}
+            <SchedulingCondition
+              condition={$schedulingConditionsMap[specCondition.condition_id]}
+              conditionPlanSpec={specCondition}
+              hasEditPermission={$plan ? featurePermissions.schedulingConditionsPlanSpec.canUpdate(user, $plan) : false}
+              modelId={$plan?.model.id}
+              permissionError={$planReadOnly
+                ? PlanStatusMessages.READ_ONLY
+                : 'You do not have permission to edit scheduling conditions for this plan.'}
+              on:updateConditionPlanSpec={onUpdateCondition}
+            />
+          {/if}
         {/each}
       {/if}
     </div>
   </svelte:fragment>
 </Panel>
+
+<style>
+  .private-label {
+    color: #e6b300;
+  }
+
+  .st-button {
+    white-space: nowrap;
+  }
+</style>
diff --git a/src/components/scheduling/SchedulingEditor.svelte b/src/components/scheduling/SchedulingEditor.svelte
deleted file mode 100644
index ccacc6a68a..0000000000
--- a/src/components/scheduling/SchedulingEditor.svelte
+++ /dev/null
@@ -1,53 +0,0 @@
-<svelte:options immutable={true} />
-
-<script lang="ts">
-  import type { User } from '../../types/app';
-  import type { Monaco, TypeScriptFile } from '../../types/monaco';
-  import effects from '../../utilities/effects';
-  import MonacoEditor from '../ui/MonacoEditor.svelte';
-  import Panel from '../ui/Panel.svelte';
-  import SectionTitle from '../ui/SectionTitle.svelte';
-
-  export let scheduleItemDefinition: string = '';
-  export let scheduleItemModelId: number | null = null;
-  export let readOnly: boolean = false;
-  export let title: string = 'Scheduling Item - Definition Editor';
-  export let user: User | null;
-
-  let monaco: Monaco;
-  let schedulingTsFiles: TypeScriptFile[];
-
-  $: effects.getTsFilesScheduling(scheduleItemModelId, user).then(tsFiles => (schedulingTsFiles = tsFiles));
-
-  $: if (monaco !== undefined && schedulingTsFiles !== undefined) {
-    const { languages } = monaco;
-    const { typescript } = languages;
-    const { typescriptDefaults } = typescript;
-    const options = typescriptDefaults.getCompilerOptions();
-
-    typescriptDefaults.setCompilerOptions({ ...options, lib: ['esnext'], strictNullChecks: true });
-    typescriptDefaults.setExtraLibs(schedulingTsFiles);
-  }
-</script>
-
-<Panel overflowYBody="hidden">
-  <svelte:fragment slot="header">
-    <SectionTitle>{title}</SectionTitle>
-  </svelte:fragment>
-
-  <svelte:fragment slot="body">
-    <MonacoEditor
-      bind:monaco
-      automaticLayout={true}
-      fixedOverflowWidgets={true}
-      language="typescript"
-      lineNumbers="on"
-      minimap={{ enabled: false }}
-      {readOnly}
-      scrollBeyondLastLine={false}
-      tabSize={2}
-      value={scheduleItemDefinition}
-      on:didChangeModelContent
-    />
-  </svelte:fragment>
-</Panel>
diff --git a/src/components/scheduling/SchedulingGoalsPanel.svelte b/src/components/scheduling/SchedulingGoalsPanel.svelte
index e6212d418c..4a505f8cfb 100644
--- a/src/components/scheduling/SchedulingGoalsPanel.svelte
+++ b/src/components/scheduling/SchedulingGoalsPanel.svelte
@@ -1,23 +1,23 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
-  import { base } from '$app/paths';
   import ChecklistIcon from '@nasa-jpl/stellar/icons/checklist.svg?component';
   import { afterUpdate, beforeUpdate } from 'svelte';
   import { PlanStatusMessages } from '../../enums/planStatusMessages';
   import { plan, planReadOnly } from '../../stores/plan';
   import {
+    allowedSchedulingGoalSpecs,
     enableScheduling,
     schedulingAnalysisStatus,
-    schedulingSpecGoals,
-    selectedSpecId,
+    schedulingGoalSpecifications,
+    schedulingGoalsMap,
   } from '../../stores/scheduling';
   import type { User } from '../../types/app';
-  import type { SchedulingSpecGoal } from '../../types/scheduling';
+  import type { SchedulingGoalPlanSpecification } from '../../types/scheduling';
   import type { ViewGridSection } from '../../types/view';
   import effects from '../../utilities/effects';
   import { permissionHandler } from '../../utilities/permissionHandler';
-  import { featurePermissions } from '../../utilities/permissions';
+  import { featurePermissions, isAdminRole } from '../../utilities/permissions';
   import CollapsibleListControls from '../CollapsibleListControls.svelte';
   import GridMenu from '../menus/GridMenu.svelte';
   import Panel from '../ui/Panel.svelte';
@@ -30,27 +30,68 @@
 
   let activeElement: HTMLElement;
   let filterText: string = '';
-  let filteredSchedulingSpecGoals: SchedulingSpecGoal[] = [];
+  let filteredSchedulingGoalSpecs: SchedulingGoalPlanSpecification[] = [];
   let hasAnalyzePermission: boolean = false;
-  let hasCreatePermission: boolean = false;
-  let hasDeletePermission: boolean = false;
-  let hasGoalEditPermission: boolean = false;
   let hasSpecEditPermission: boolean = false;
   let hasRunPermission: boolean = false;
+  let numOfPrivateGoals: number = 0;
+  let visibleSchedulingGoalSpecs: SchedulingGoalPlanSpecification[] = [];
 
-  $: filteredSchedulingSpecGoals = $schedulingSpecGoals.filter(spec => {
-    const filterTextLowerCase = filterText.toLowerCase();
-    const includesName = spec.goal.name.toLocaleLowerCase().includes(filterTextLowerCase);
-    return includesName;
+  // TODO: remove this after db merge as it becomes redundant
+  $: visibleSchedulingGoalSpecs = $allowedSchedulingGoalSpecs.filter(({ goal_metadata: goalMetadata }) => {
+    if (goalMetadata) {
+      const { public: isPublic, owner } = goalMetadata;
+      if (!isPublic && !isAdminRole(user?.activeRole)) {
+        return owner === user?.id;
+      }
+      return true;
+    }
+    return false;
   });
-
+  $: filteredSchedulingGoalSpecs = visibleSchedulingGoalSpecs
+    .filter(spec => {
+      const filterTextLowerCase = filterText.toLowerCase();
+      const includesName = spec.goal_metadata?.name.toLocaleLowerCase().includes(filterTextLowerCase);
+      return includesName;
+    })
+    .sort((goalSpecA, goalSpecB) => {
+      if (goalSpecA.priority < goalSpecB.priority) {
+        return -1;
+      }
+      if (goalSpecA.priority > goalSpecB.priority) {
+        return 1;
+      }
+      return 0;
+    });
+  $: numOfPrivateGoals = $schedulingGoalSpecifications.length - visibleSchedulingGoalSpecs.length;
   $: if ($plan) {
-    hasAnalyzePermission = featurePermissions.schedulingGoals.canAnalyze(user, $plan, $plan.model) && !$planReadOnly;
-    hasCreatePermission = featurePermissions.schedulingGoals.canCreate(user, $plan) && !$planReadOnly;
-    hasDeletePermission = featurePermissions.schedulingGoals.canDelete(user, $plan) && !$planReadOnly;
-    hasGoalEditPermission = featurePermissions.schedulingGoals.canUpdate(user, $plan) && !$planReadOnly;
-    hasSpecEditPermission = featurePermissions.schedulingGoals.canUpdateSpecification(user, $plan) && !$planReadOnly;
-    hasRunPermission = featurePermissions.schedulingGoals.canRun(user, $plan, $plan.model) && !$planReadOnly;
+    hasAnalyzePermission =
+      featurePermissions.schedulingGoalsPlanSpec.canAnalyze(user, $plan, $plan.model) && !$planReadOnly;
+    hasSpecEditPermission =
+      featurePermissions.schedulingGoalsPlanSpec.canUpdateSpecification(user, $plan) && !$planReadOnly;
+    hasRunPermission = featurePermissions.schedulingGoalsPlanSpec.canRun(user, $plan, $plan.model) && !$planReadOnly;
+  }
+
+  function onManageGoals() {
+    effects.managePlanSchedulingGoals(user);
+  }
+
+  async function onUpdateGoal(event: CustomEvent<SchedulingGoalPlanSpecification>) {
+    const {
+      detail: { goal_metadata, specification_id, ...goalPlanSpec },
+    } = event;
+
+    if ($plan) {
+      await effects.updateSchedulingGoalPlanSpecification(
+        $plan,
+        specification_id,
+        {
+          ...goalPlanSpec,
+          specification_id,
+        },
+        user,
+      );
+    }
   }
 
   // Manually keep focus as scheduling goal elements are re-ordered.
@@ -113,44 +154,63 @@
       placeholder="Filter scheduling goals"
       on:input={event => (filterText = event.detail.value)}
     >
-      <button
-        slot="right"
-        name="new-scheduling-goal"
-        class="st-button secondary"
-        use:permissionHandler={{
-          hasPermission: hasCreatePermission,
-          permissionError: $planReadOnly
-            ? PlanStatusMessages.READ_ONLY
-            : 'You do not have permission to create scheduling goals for this plan.',
-        }}
-        on:click={() =>
-          window.open(`${base}/scheduling/goals/new?modelId=${$plan?.model.id}&&specId=${$selectedSpecId}`, '_blank')}
-      >
-        New
-      </button>
+      <svelte:fragment slot="right">
+        <button
+          name="manage-goals"
+          class="st-button secondary"
+          use:permissionHandler={{
+            hasPermission: $plan ? featurePermissions.schedulingGoals.canCreate(user) && !$planReadOnly : false,
+            permissionError: $planReadOnly
+              ? PlanStatusMessages.READ_ONLY
+              : 'You do not have permission to update scheduling goals',
+          }}
+          on:click|stopPropagation={onManageGoals}
+        >
+          Manage Goals
+        </button>
+      </svelte:fragment>
     </CollapsibleListControls>
     <div class="pt-2">
-      {#if !filteredSchedulingSpecGoals.length}
+      {#if !filteredSchedulingGoalSpecs.length}
         <div class="pt-1 st-typography-label">No scheduling goals found</div>
+        <div class="private-label">
+          {#if numOfPrivateGoals > 0}
+            {numOfPrivateGoals} scheduling goal{numOfPrivateGoals !== 1 ? 's' : ''}
+            {numOfPrivateGoals > 1 ? 'are' : 'is'} private and not shown
+          {/if}
+        </div>
       {:else}
-        {#each filteredSchedulingSpecGoals as specGoal (specGoal.goal.id)}
-          <SchedulingGoal
-            enabled={specGoal.enabled}
-            {hasDeletePermission}
-            {hasGoalEditPermission}
-            {hasSpecEditPermission}
-            goal={specGoal.goal}
-            priority={specGoal.priority}
-            plan={$plan}
-            simulateAfter={specGoal.simulate_after}
-            specificationId={specGoal.specification_id}
-            {user}
-            permissionError={$planReadOnly
-              ? PlanStatusMessages.READ_ONLY
-              : 'You do not have permission to edit scheduling goals for this plan.'}
-          />
+        <div class="private-label">
+          {#if numOfPrivateGoals > 0}
+            {numOfPrivateGoals} scheduling goal{numOfPrivateGoals !== 1 ? 's' : ''}
+            {numOfPrivateGoals > 1 ? 'are' : 'is'} private and not shown
+          {/if}
+        </div>
+        {#each filteredSchedulingGoalSpecs as specGoal (specGoal.goal_id)}
+          {#if $schedulingGoalsMap[specGoal.goal_id]}
+            <SchedulingGoal
+              hasEditPermission={hasSpecEditPermission}
+              goal={$schedulingGoalsMap[specGoal.goal_id]}
+              goalPlanSpec={specGoal}
+              modelId={$plan?.model.id}
+              permissionError={$planReadOnly
+                ? PlanStatusMessages.READ_ONLY
+                : 'You do not have permission to edit scheduling goals for this plan.'}
+              on:updateGoalPlanSpec={onUpdateGoal}
+            />
+          {/if}
         {/each}
       {/if}
     </div>
   </svelte:fragment>
 </Panel>
+
+<style>
+  .private-label {
+    color: #e6b300;
+  }
+
+  .st-button {
+    white-space: nowrap;
+  }
+</style>
diff --git a/src/components/scheduling/conditions/SchedulingCondition.svelte b/src/components/scheduling/conditions/SchedulingCondition.svelte
index b6ae76db74..3f07effd1d 100644
--- a/src/components/scheduling/conditions/SchedulingCondition.svelte
+++ b/src/components/scheduling/conditions/SchedulingCondition.svelte
@@ -2,48 +2,103 @@
 
 <script lang="ts">
   import { base } from '$app/paths';
-  import type { User } from '../../../types/app';
-  import type { Plan } from '../../../types/plan';
-  import type { SchedulingCondition } from '../../../types/scheduling';
-  import effects from '../../../utilities/effects';
+  import { createEventDispatcher } from 'svelte';
+  import { PlanStatusMessages } from '../../../enums/planStatusMessages';
+  import { SearchParameters } from '../../../enums/searchParameters';
+  import type { SchedulingConditionMetadata, SchedulingConditionPlanSpecification } from '../../../types/scheduling';
+  import { getTarget } from '../../../utilities/generic';
   import { permissionHandler } from '../../../utilities/permissionHandler';
+  import { tooltip } from '../../../utilities/tooltip';
   import Collapse from '../../Collapse.svelte';
-  import ContextMenuHeader from '../../context-menu/ContextMenuHeader.svelte';
   import ContextMenuItem from '../../context-menu/ContextMenuItem.svelte';
-  import Input from '../../form/Input.svelte';
 
-  export let condition: SchedulingCondition;
-  export let enabled: boolean;
-  export let hasDeletePermission: boolean = false;
+  export let condition: SchedulingConditionMetadata;
+  export let conditionPlanSpec: SchedulingConditionPlanSpecification;
   export let hasEditPermission: boolean = false;
-  export let plan: Plan | null;
+  export let modelId: number | undefined;
   export let permissionError: string = '';
-  export let specificationId: number;
-  export let user: User | null;
+  export let readOnly: boolean = false;
+
+  const dispatch = createEventDispatcher();
+
+  let revisions: number[] = [];
+
+  $: revisions = condition.versions
+    .map(({ revision }) => revision)
+    .sort((revisionA, revisionB) => revisionB - revisionA);
+
+  function onEnable(event: Event) {
+    const { value: enabled } = getTarget(event);
+    dispatch('updateConditionPlanSpec', {
+      ...conditionPlanSpec,
+      enabled,
+    });
+  }
+
+  function onUpdateRevision(event: Event) {
+    const { value: revision } = getTarget(event);
+    dispatch('updateConditionPlanSpec', {
+      ...conditionPlanSpec,
+      condition_revision: revision === '' ? null : parseInt(`${revision}`),
+    });
+  }
 </script>
 
-<div class="scheduling-condition" class:disabled={!enabled}>
+<div class="scheduling-condition" class:disabled={!conditionPlanSpec.enabled}>
   <Collapse title={condition.name} tooltipContent={condition.name} collapsible={false}>
+    <svelte:fragment slot="left">
+      <div class="left-content">
+        <input
+          type="checkbox"
+          checked={conditionPlanSpec.enabled}
+          style:cursor="pointer"
+          on:change={onEnable}
+          on:click|stopPropagation
+          use:permissionHandler={{
+            hasPermission: hasEditPermission,
+            permissionError,
+          }}
+          use:tooltip={{
+            content: `${conditionPlanSpec.enabled ? 'Disable condition' : 'Enable condition'} on plan`,
+            disabled: !hasEditPermission,
+            placement: 'top',
+          }}
+        />
+      </div>
+    </svelte:fragment>
     <svelte:fragment slot="right">
       <div class="right-content">
-        <Input>
-          <input
-            bind:checked={enabled}
-            style:cursor="pointer"
-            type="checkbox"
-            on:change={() => effects.updateSchedulingSpecCondition(condition.id, specificationId, { enabled }, user)}
-            use:permissionHandler={{
-              hasPermission: hasEditPermission,
-              permissionError,
-            }}
-          />
-        </Input>
+        <select
+          class="st-select"
+          value={conditionPlanSpec.condition_revision}
+          on:change={onUpdateRevision}
+          on:click|stopPropagation
+          use:permissionHandler={{
+            hasPermission: hasEditPermission,
+            permissionError: readOnly
+              ? PlanStatusMessages.READ_ONLY
+              : 'You do not have permission to edit plan conditions',
+          }}
+        >
+          <option value={null}>Always use latest</option>
+          {#each revisions as revision, index}
+            <option value={revision}>{revision}{index === 0 ? ' (Latest)' : ''}</option>
+          {/each}
+        </select>
       </div>
     </svelte:fragment>
+
     <svelte:fragment slot="contextMenuContent">
-      <ContextMenuHeader>Actions</ContextMenuHeader>
       <ContextMenuItem
-        on:click={() => window.open(`${base}/scheduling/conditions/edit/${condition.id}`, '_blank')}
+        on:click={() =>
+          window.open(
+            `${base}/scheduling/conditions/edit/${condition.id}${
+              conditionPlanSpec.condition_revision !== null
+                ? `?${SearchParameters.REVISION}=${conditionPlanSpec.condition_revision}&${SearchParameters.MODEL_ID}=${modelId}`
+                : ''
+            }`,
+            '_blank',
+          )}
         use={[
           [
             permissionHandler,
@@ -56,21 +111,6 @@
       >
         Edit Condition
       </ContextMenuItem>
-      <ContextMenuHeader>Modify</ContextMenuHeader>
-      <ContextMenuItem
-        on:click={() => plan && effects.deleteSchedulingCondition(condition, plan, user)}
-        use={[
-          [
-            permissionHandler,
-            {
-              hasPermission: hasDeletePermission,
-              permissionError,
-            },
-          ],
-        ]}
-      >
-        Delete Condition
-      </ContextMenuItem>
     </svelte:fragment>
   </Collapse>
 </div>
diff --git a/src/components/scheduling/conditions/SchedulingConditionEditor.svelte b/src/components/scheduling/conditions/SchedulingConditionEditor.svelte
deleted file mode 100644
index 4ca5a7d868..0000000000
--- a/src/components/scheduling/conditions/SchedulingConditionEditor.svelte
+++ /dev/null
@@ -1,53 +0,0 @@
-<svelte:options immutable={true} />
-
-<script lang="ts">
-  import type { User } from '../../../types/app';
-  import type { Monaco, TypeScriptFile } from '../../../types/monaco';
-  import effects from '../../../utilities/effects';
-  import MonacoEditor from '../../ui/MonacoEditor.svelte';
-  import Panel from '../../ui/Panel.svelte';
-  import SectionTitle from '../../ui/SectionTitle.svelte';
-
-  export let conditionDefinition: string = '';
-  export let conditionModelId: number | null = null;
-  export let readOnly: boolean = false;
-  export let title: string = 'Scheduling Condition - Definition Editor';
-  export let user: User | null;
-
-  let monaco: Monaco;
-  let schedulingTsFiles: TypeScriptFile[];
-
-  $: effects.getTsFilesScheduling(conditionModelId, user).then(tsFiles => (schedulingTsFiles = tsFiles));
-
-  $: if (monaco !== undefined && schedulingTsFiles !== undefined) {
-    const { languages } = monaco;
-    const { typescript } = languages;
-    const { typescriptDefaults } = typescript;
-    const options = typescriptDefaults.getCompilerOptions();
-
-    typescriptDefaults.setCompilerOptions({ ...options, lib: ['esnext'], strictNullChecks: true });
-    typescriptDefaults.setExtraLibs(schedulingTsFiles);
-  }
-</script>
-
-<Panel overflowYBody="hidden">
-  <svelte:fragment slot="header">
-    <SectionTitle>{title}</SectionTitle>
-  </svelte:fragment>
-
-  <svelte:fragment slot="body">
-    <MonacoEditor
-      bind:monaco
-      automaticLayout={true}
-      fixedOverflowWidgets={true}
-      language="typescript"
-      lineNumbers="on"
-      minimap={{ enabled: false }}
-      {readOnly}
-      scrollBeyondLastLine={false}
-      tabSize={2}
-      value={conditionDefinition}
-      on:didChangeModelContent
-    />
-  </svelte:fragment>
-</Panel>
diff --git a/src/components/scheduling/conditions/SchedulingConditionForm.svelte b/src/components/scheduling/conditions/SchedulingConditionForm.svelte
index fff53fc9b4..301091840a 100644
--- a/src/components/scheduling/conditions/SchedulingConditionForm.svelte
+++ b/src/components/scheduling/conditions/SchedulingConditionForm.svelte
@@ -3,316 +3,238 @@
 <script lang="ts">
   import { goto } from '$app/navigation';
   import { base } from '$app/paths';
-  import { schedulingConditionsFormColumns } from '../../../stores/scheduling';
-  import type { User } from '../../../types/app';
-  import type { ModelSlim } from '../../../types/model';
-  import type { PlanSchedulingSpec } from '../../../types/plan';
-  import type { SchedulingCondition, SchedulingSpecConditionInsertInput } from '../../../types/scheduling';
+  import { createEventDispatcher } from 'svelte';
+  import { SearchParameters } from '../../../enums/searchParameters';
+  import { schedulingConditions } from '../../../stores/scheduling';
+  import type { User, UserId } from '../../../types/app';
+  import type { TypeScriptFile } from '../../../types/monaco';
+  import type {
+    SchedulingConditionDefinitionTagsInsertInput,
+    SchedulingConditionMetadataTagsInsertInput,
+    Tag,
+  } from '../../../types/tags';
   import effects from '../../../utilities/effects';
-  import { isSaveEvent } from '../../../utilities/keyboardEvents';
-  import { permissionHandler } from '../../../utilities/permissionHandler';
-  import { featurePermissions, isUserAdmin } from '../../../utilities/permissions';
-  import CssGrid from '../../ui/CssGrid.svelte';
-  import CssGridGutter from '../../ui/CssGridGutter.svelte';
-  import Panel from '../../ui/Panel.svelte';
-  import SectionTitle from '../../ui/SectionTitle.svelte';
-  import SchedulingEditor from '../SchedulingEditor.svelte';
+  import { featurePermissions } from '../../../utilities/permissions';
+  import AssociationForm from '../../ui/Association/AssociationForm.svelte';
 
-  export let initialConditionAuthor: string | null = null;
-  export let initialConditionCreatedDate: string | null = null;
-  export let initialConditionDefinition: string = 'export default (): GlobalSchedulingCondition => {\n\n}\n';
+  export let initialConditionDefinitionAuthor: UserId | undefined = undefined;
+  export let initialConditionDefinitionCode: string = 'export default (): GlobalSchedulingCondition => {\n\n}\n';
   export let initialConditionDescription: string = '';
   export let initialConditionId: number | null = null;
-  export let initialConditionModelId: number | null = null;
-  export let initialConditionModifiedDate: string | null = null;
   export let initialConditionName: string = '';
-  export let initialSpecId: number | null = null;
+  export let initialConditionPublic: boolean = true;
+  export let initialConditionDefinitionTags: Tag[] = [];
+  export let initialConditionMetadataTags: Tag[] = [];
+  export let initialConditionOwner: UserId = null;
+  export let initialConditionRevision: number | null = null;
+  export let initialReferenceModelId: number | null = null;
+  export let conditionRevisions: number[] = [];
+  export let tags: Tag[] = [];
   export let mode: 'create' | 'edit' = 'create';
-  export let models: ModelSlim[] = [];
-  export let plans: PlanSchedulingSpec[] = [];
   export let user: User | null;
 
-  const permissionError = 'You do not have permission to edit this scheduling condition.';
+  const dispatch = createEventDispatcher();
 
-  let conditionAuthor: string | null = initialConditionAuthor;
-  let conditionCreatedDate: string | null = initialConditionCreatedDate;
-  let conditionDefinition: string = initialConditionDefinition;
-  let conditionDescription: string = initialConditionDescription;
-  let conditionId: number | null = initialConditionId;
-  let conditionModelId: number | null = initialConditionModelId;
-  let conditionModifiedDate: string | null = initialConditionModifiedDate;
-  let conditionName: string = initialConditionName;
-  let hasAuthoringPermission: boolean = false;
-  let hasPermission: boolean = false;
-  let planOptions: (PlanSchedulingSpec & { specId: number | null })[] = [];
-  let saveButtonEnabled: boolean = false;
-  let specId: number | null = initialSpecId;
-  let savedSpecId: number | null = initialSpecId;
-  let savedCondition: Partial<SchedulingCondition> = {
-    definition: conditionDefinition,
-    description: conditionDescription,
-    model_id: conditionModelId !== null ? conditionModelId : undefined,
-    name: conditionName,
-  };
+  const permissionError = `You do not have permission to ${
+    mode === 'edit' ? 'edit this' : 'create a'
+  } scheduling condition.`;
 
-  $: planOptions = plans
-    .filter(plan => plan.model_id === conditionModelId)
-    .map(({ scheduling_specification, ...plan }) => ({
-      ...plan,
-      scheduling_specification,
-      specId: scheduling_specification ? scheduling_specification.id : null,
-    }));
-  $: selectedPlan = planOptions.find(({ specId: planSpecId }) => planSpecId === specId);
-  $: specId = planOptions.some(plan => plan.specId === specId) ? specId : null; // Null the specId value if the filtered plan list no longer includes the chosen spec
+  let hasCreateDefinitionCodePermission: boolean = false;
+  let hasWriteMetadataPermission: boolean = false;
 
-  $: hasAuthoringPermission = mode === 'edit' ? isUserAdmin(user) : true;
-  $: if (user) {
-    hasPermission = specId
-      ? hasPlanPermission(planOptions.find(plan => plan.specId === specId)?.id, mode, user)
-      : conditionModelId
-      ? hasModelPermission(conditionModelId, mode, user)
-      : hasAnyPlanPermission(mode, user);
-  }
-  $: saveButtonEnabled =
-    conditionDefinition !== '' && conditionModelId !== null && conditionName !== '' && specId !== null;
-  $: conditionModified =
-    diffConditions(savedCondition, {
-      definition: conditionDefinition,
-      description: conditionDescription,
-      ...(conditionModelId !== null ? { model_id: conditionModelId } : {}),
-      name: conditionName,
-    }) || specId !== savedSpecId;
-  $: saveButtonText = mode === 'edit' && !conditionModified ? 'Saved' : 'Save';
-  $: saveButtonClass = conditionModified && saveButtonEnabled ? 'primary' : 'secondary';
+  let conditionsTsFiles: TypeScriptFile[] = [];
+  $: hasCreateDefinitionCodePermission = featurePermissions.schedulingConditions.canCreate(user);
+  $: hasWriteMetadataPermission =
+    mode === 'create'
+      ? featurePermissions.schedulingConditions.canCreate(user)
+      : featurePermissions.schedulingConditions.canUpdate(user, { owner: initialConditionOwner });
+  $: selectReferenceModel(initialReferenceModelId);
 
-  function hasModelPermission(modelId: number, mode: 'create' | 'edit', user: User | null): boolean {
-    const plansFromModel = plans.filter(plan => plan.model_id === modelId);
-    return plansFromModel.some(plan => {
-      return (
-        (mode === 'create' && featurePermissions.schedulingConditions.canCreate(user, plan)) ||
-        featurePermissions.schedulingConditions.canUpdate(user, plan)
-      );
-    });
+  function selectReferenceModel(modelId: number | null) {
+    if (modelId !== null) {
+      effects.getTsFilesScheduling(modelId, user).then(tsFiles => (conditionsTsFiles = tsFiles));
+    } else {
+      conditionsTsFiles = [];
+    }
   }
 
-  function hasAnyPlanPermission(mode: 'create' | 'edit', user: User | null): boolean {
-    return plans.some(plan => {
-      return mode === 'create'
-        ? featurePermissions.schedulingConditions.canCreate(user, plan)
-        : featurePermissions.schedulingConditions.canUpdate(user, plan);
-    });
+  function selectRevision(revision: number | string) {
+    dispatch('selectRevision', parseInt(`${revision}`));
   }
 
-  function hasPlanPermission(planId: number | undefined, mode: 'create' | 'edit', user: User | null): boolean {
-    const plan = plans.find(plan => plan.id === planId);
-    if (plan) {
-      return mode === 'create'
-        ? featurePermissions.schedulingConditions.canCreate(user, plan)
-        : featurePermissions.schedulingConditions.canUpdate(user, plan);
-    }
-    return false;
+  function onRevisionSelection(event: CustomEvent) {
+    const { detail } = event;
+
+    selectRevision(`${detail}`);
   }
 
-  function diffConditions(conditionA: Partial<SchedulingCondition>, conditionB: Partial<SchedulingCondition>) {
-    return Object.entries(conditionA).some(([key, value]) => {
-      return conditionB[key as keyof SchedulingCondition] !== value;
-    });
+  function onSelectReferenceModel(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    selectReferenceModel(modelId);
+    dispatch('selectReferenceModel', modelId);
   }
 
-  function onDidChangeModelContent(event: CustomEvent<{ value: string }>) {
-    const { detail } = event;
-    const { value } = detail;
-    conditionDefinition = value;
+  function onClose() {
+    goto(`${base}/scheduling/conditions`);
   }
 
-  function onKeydown(event: KeyboardEvent): void {
-    if (isSaveEvent(event)) {
-      event.preventDefault();
-      saveCondition();
+  async function onCreateCondition(
+    event: CustomEvent<{
+      definition: {
+        code: string;
+        tags: Tag[];
+      };
+      description: string;
+      name: string;
+      public: boolean;
+      tags: Tag[];
+    }>,
+  ) {
+    const {
+      detail: { definition, description, name, public: isPublic, tags },
+    } = event;
+
+    const newConditionId = await effects.createSchedulingCondition(
+      name,
+      isPublic,
+      tags.map(({ id }) => ({ tag_id: id })),
+      definition.code,
+      definition.tags.map(({ id }) => ({ tag_id: id })),
+      user,
+      description,
+    );
+
+    if (newConditionId !== null) {
+      goto(
+        `${base}/scheduling/conditions/edit/${newConditionId}${
+          initialReferenceModelId !== null ? `?${SearchParameters.MODEL_ID}=${initialReferenceModelId}` : ''
+        }`,
+      );
     }
   }
 
-  async function saveCondition() {
-    if (saveButtonEnabled) {
-      if (mode === 'create') {
-        let newCondition: SchedulingCondition | null = null;
-        if (conditionModelId !== null && selectedPlan) {
-          newCondition = await effects.createSchedulingCondition(
-            conditionDefinition,
-            conditionName,
-            conditionModelId,
-            selectedPlan,
-            user,
-            conditionDescription,
-          );
-        }
-
-        if (newCondition !== null && specId !== null) {
-          const { id: newConditionId } = newCondition;
-
-          const specConditionInsertInput: SchedulingSpecConditionInsertInput = {
-            condition_id: newConditionId,
-            enabled: true,
-            specification_id: specId,
-          };
-          await effects.createSchedulingSpecCondition(specConditionInsertInput, user);
-
-          goto(`${base}/scheduling/conditions/edit/${newConditionId}`);
-        }
-      } else if (mode === 'edit') {
-        const condition: Partial<SchedulingCondition> = {
-          definition: conditionDefinition,
-          description: conditionDescription,
-          ...(hasAuthoringPermission && conditionModelId !== null ? { model_id: conditionModelId } : {}),
-          name: conditionName,
-        };
-        if (conditionId !== null && selectedPlan != null) {
-          const updatedCondition = await effects.updateSchedulingCondition(conditionId, condition, selectedPlan, user);
-          if (updatedCondition) {
-            if (savedSpecId !== null && specId !== null && specId !== savedSpecId) {
-              await effects.updateSchedulingSpecConditionId(conditionId, savedSpecId, specId, user);
-              savedSpecId = specId;
-            }
+  async function onCreateNewConditionDefinition(
+    event: CustomEvent<{
+      definitionCode: string;
+      definitionTags: Tag[];
+    }>,
+  ) {
+    const {
+      detail: { definitionCode, definitionTags },
+    } = event;
+    if (initialConditionId !== null) {
+      const definition = await effects.createSchedulingConditionDefinition(
+        initialConditionId,
+        definitionCode,
+        definitionTags.map(({ id }) => ({ tag_id: id })),
+        user,
+      );
 
-            conditionModifiedDate = updatedCondition.modified_date;
-            savedCondition = { ...condition };
-          }
-        }
+      if (definition !== null) {
+        selectRevision(definition.revision);
       }
     }
   }
-</script>
-
-<svelte:window on:keydown={onKeydown} />
-
-<CssGrid bind:columns={$schedulingConditionsFormColumns}>
-  <Panel overflowYBody="hidden" padBody={false}>
-    <svelte:fragment slot="header">
-      <SectionTitle>{mode === 'create' ? 'New Scheduling Condition' : 'Edit Scheduling Condition'}</SectionTitle>
-
-      <div class="right">
-        <button class="st-button secondary ellipsis" on:click={() => goto(`${base}/scheduling/conditions`)}>
-          {mode === 'create' ? 'Cancel' : 'Close'}
-        </button>
-        <button
-          class="st-button {saveButtonClass} ellipsis"
-          disabled={!saveButtonEnabled}
-          on:click|stopPropagation={saveCondition}
-          use:permissionHandler={{
-            hasPermission,
-            permissionError,
-          }}
-        >
-          {saveButtonText}
-        </button>
-      </div>
-    </svelte:fragment>
 
-    <svelte:fragment slot="body">
-      {#if mode === 'edit'}
-        <fieldset>
-          <label for="conditionId">Condition ID</label>
-          <input class="st-input w-100" disabled name="conditionId" value={conditionId} />
-        </fieldset>
-
-        <fieldset>
-          <label for="createdAt">Created At</label>
-          <input class="st-input w-100" disabled name="createdAt" value={conditionCreatedDate} />
-        </fieldset>
-
-        <fieldset>
-          <label for="updatedAt">Updated At</label>
-          <input class="st-input w-100" disabled name="updatedAt" value={conditionModifiedDate} />
-        </fieldset>
-
-        <fieldset>
-          <label for="author">Original Author</label>
-          <input class="st-input w-100" disabled name="author" value={conditionAuthor} />
-        </fieldset>
-      {/if}
-
-      <fieldset>
-        <label for="model">Model</label>
-        <select
-          bind:value={conditionModelId}
-          class="st-select w-100"
-          name="model"
-          use:permissionHandler={{
-            hasPermission: hasAnyPlanPermission(mode, user) && hasAuthoringPermission,
-            permissionError,
-          }}
-        >
-          <option value={null} />
-          {#each models as model}
-            <option value={model.id} disabled={!hasModelPermission(model.id, mode, user)}>
-              {model.name}
-              (Version: {model.version})
-            </option>
-          {/each}
-        </select>
-      </fieldset>
-
-      <fieldset>
-        <label for="plan">Plan</label>
-        <select
-          bind:value={specId}
-          class="st-select w-100"
-          name="plan"
-          use:permissionHandler={{
-            hasPermission: hasAnyPlanPermission(mode, user),
-            permissionError,
-          }}
-        >
-          <option value={null} />
-          {#each planOptions as plan}
-            <option value={plan.specId} disabled={plan.specId === null || !hasPlanPermission(plan.id, mode, user)}>
-              {plan.name} ({plan.id}) {#if plan.specId === null} (Missing Scheduling Specification) {/if}
-            </option>
-          {/each}
-        </select>
-      </fieldset>
-
-      <fieldset>
-        <label for="condition-name">Name</label>
-        <input
-          bind:value={conditionName}
-          autocomplete="off"
-          class="st-input w-100"
-          name="condition-name"
-          placeholder="Enter Condition Name (required)"
-          required
-          use:permissionHandler={{
-            hasPermission,
-            permissionError,
-          }}
-        />
-      </fieldset>
+  async function onSaveConditionMetadata(
+    event: CustomEvent<{
+      metadata: {
+        description: string;
+        name: string;
+        owner: UserId;
+        public: boolean;
+      };
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>,
+  ) {
+    if (initialConditionId !== null) {
+      const {
+        detail: {
+          metadata: { description, name, owner, public: isPublic },
+          tagIdsToDelete,
+          tagsToUpdate,
+        },
+      } = event;
+      const conditionMetadataTagsToUpdate: SchedulingConditionMetadataTagsInsertInput[] = tagsToUpdate.map(
+        ({ id }) => ({
+          condition_id: initialConditionId as number,
+          tag_id: id,
+        }),
+      );
 
-      <fieldset>
-        <label for="condition-description">Description</label>
-        <textarea
-          bind:value={conditionDescription}
-          autocomplete="off"
-          class="st-input w-100"
-          name="condition-description"
-          placeholder="Enter Condition Description (optional)"
-          use:permissionHandler={{
-            hasPermission,
-            permissionError,
-          }}
-        />
-      </fieldset>
-    </svelte:fragment>
-  </Panel>
+      await effects.updateSchedulingConditionMetadata(
+        initialConditionId,
+        {
+          description,
+          name,
+          owner,
+          public: isPublic,
+        },
+        conditionMetadataTagsToUpdate,
+        tagIdsToDelete,
+        initialConditionOwner,
+        user,
+      );
+    }
+  }
 
-  <CssGridGutter track={1} type="column" />
+  async function onSaveConditionDefinitionRevisionTags(
+    event: CustomEvent<{
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>,
+  ) {
+    if (initialConditionId !== null && initialConditionRevision !== null) {
+      const {
+        detail: { tagIdsToDelete, tagsToUpdate },
+      } = event;
+      // Associate new tags with condition definition version
+      const conditionDefinitionTagsToUpdate: SchedulingConditionDefinitionTagsInsertInput[] = tagsToUpdate.map(
+        ({ id }) => ({
+          condition_id: initialConditionId as number,
+          condition_revision: initialConditionRevision as number,
+          tag_id: id,
+        }),
+      );
+      await effects.updateSchedulingConditionDefinitionTags(
+        initialConditionId,
+        initialConditionRevision,
+        conditionDefinitionTagsToUpdate,
+        tagIdsToDelete,
+        user,
+      );
+    }
+  }
+</script>
 
-  <SchedulingEditor
-    scheduleItemDefinition={conditionDefinition}
-    scheduleItemModelId={conditionModelId}
-    title="{mode === 'create' ? 'New' : 'Edit'} Scheduling Condition - Definition Editor"
-    {user}
-    readOnly={!hasPermission}
-    on:didChangeModelContent={onDidChangeModelContent}
-  />
-</CssGrid>
+<AssociationForm
+  allMetadata={$schedulingConditions}
+  displayName="Scheduling Condition"
+  {hasCreateDefinitionCodePermission}
+  {hasWriteMetadataPermission}
+  initialDefinitionAuthor={initialConditionDefinitionAuthor}
+  initialDefinitionCode={initialConditionDefinitionCode}
+  initialDescription={initialConditionDescription}
+  initialId={initialConditionId}
+  initialName={initialConditionName}
+  initialPublic={initialConditionPublic}
+  initialDefinitionTags={initialConditionDefinitionTags}
+  initialMetadataTags={initialConditionMetadataTags}
+  initialOwner={initialConditionOwner}
+  initialRevision={initialConditionRevision}
+  {initialReferenceModelId}
+  {permissionError}
+  revisions={conditionRevisions}
+  {tags}
+  tsFiles={conditionsTsFiles}
+  {mode}
+  {user}
+  on:close={onClose}
+  on:createDefinition={onCreateNewConditionDefinition}
+  on:createMetadata={onCreateCondition}
+  on:updateDefinitionTags={onSaveConditionDefinitionRevisionTags}
+  on:updateMetadata={onSaveConditionMetadata}
+  on:selectRevision={onRevisionSelection}
+  on:selectReferenceModel={onSelectReferenceModel}
+/>
diff --git a/src/components/scheduling/conditions/SchedulingConditions.svelte b/src/components/scheduling/conditions/SchedulingConditions.svelte
index 6d2f3000a2..42a1cc20e4 100644
--- a/src/components/scheduling/conditions/SchedulingConditions.svelte
+++ b/src/components/scheduling/conditions/SchedulingConditions.svelte
@@ -3,94 +3,95 @@
 <script lang="ts">
   import { goto } from '$app/navigation';
   import { base } from '$app/paths';
-  import type { ICellRendererParams } from 'ag-grid-community';
+  import type { ICellRendererParams, ValueGetterParams } from 'ag-grid-community';
   import { createEventDispatcher } from 'svelte';
   import type { User } from '../../../types/app';
   import type { DataGridColumnDef, DataGridRowSelection, RowId } from '../../../types/data-grid';
-  import type { PlanSchedulingSpec } from '../../../types/plan';
-  import type { SchedulingCondition } from '../../../types/scheduling';
+  import type { SchedulingConditionMetadata } from '../../../types/scheduling';
   import { permissionHandler } from '../../../utilities/permissionHandler';
   import { featurePermissions } from '../../../utilities/permissions';
   import Input from '../../form/Input.svelte';
   import DataGridActions from '../../ui/DataGrid/DataGridActions.svelte';
+  import { tagsCellRenderer, tagsFilterValueGetter } from '../../ui/DataGrid/DataGridTags';
   import SingleActionDataGrid from '../../ui/DataGrid/SingleActionDataGrid.svelte';
   import Panel from '../../ui/Panel.svelte';
   import SectionTitle from '../../ui/SectionTitle.svelte';
 
-  export let schedulingConditions: SchedulingCondition[] = [];
-  export let selectedCondition: SchedulingCondition | null | undefined = null;
+  export let schedulingConditions: SchedulingConditionMetadata[] = [];
+  export let selectedCondition: SchedulingConditionMetadata | null | undefined = null;
   export let user: User | null;
-  export let plans: PlanSchedulingSpec[] | null;
 
   type CellRendererParams = {
-    deleteCondition: (condition: SchedulingCondition) => void;
-    editCondition: (condition: SchedulingCondition) => void;
+    deleteCondition: (condition: SchedulingConditionMetadata) => void;
+    editCondition: (condition: SchedulingConditionMetadata) => void;
   };
-  type SchedulingConditionsCellRendererParams = ICellRendererParams<SchedulingCondition> & CellRendererParams;
-
-  let columnDefs: DataGridColumnDef[] = [];
-  $: if (user && plans) {
-    columnDefs = [
-      {
-        field: 'id',
-        filter: 'number',
-        headerName: 'ID',
-        resizable: true,
-        sortable: true,
-        suppressAutoSize: true,
-        suppressSizeToFit: true,
-        width: 60,
-      },
-      { field: 'name', filter: 'text', headerName: 'Name', resizable: true, sortable: true },
-      { field: 'model_id', filter: 'number', headerName: 'Model ID', sortable: true, width: 120 },
-      { field: 'author', filter: 'string', headerName: 'Author', sortable: true, width: 100 },
-      { field: 'last_modified_by', filter: 'string', headerName: 'Last Modified By', sortable: true, width: 100 },
-      { field: 'description', filter: 'string', headerName: 'Description', sortable: true, width: 120 },
-      {
-        cellClass: 'action-cell-container',
-        cellRenderer: (params: SchedulingConditionsCellRendererParams) => {
-          const actionsDiv = document.createElement('div');
-          actionsDiv.className = 'actions-cell';
-          new DataGridActions({
-            props: {
-              deleteCallback: params.deleteCondition,
-              deleteTooltip: {
-                content: 'Delete Condition',
-                placement: 'bottom',
-              },
-              editCallback: params.editCondition,
-              editTooltip: {
-                content: 'Edit Condition',
-                placement: 'bottom',
-              },
-              hasDeletePermission: params.data ? hasDeletePermission(params.data) : false,
-              hasEditPermission: params.data ? hasEditPermission(params.data) : false,
-              rowData: params.data,
-            },
-            target: actionsDiv,
-          });
-
-          return actionsDiv;
-        },
-        cellRendererParams: {
-          deleteCondition,
-          editCondition,
-        } as CellRendererParams,
-        field: 'actions',
-        headerName: '',
-        resizable: false,
-        sortable: false,
-        suppressAutoSize: true,
-        suppressSizeToFit: true,
-        width: 55,
-      },
-    ];
-  }
+  type SchedulingConditionsCellRendererParams = ICellRendererParams<SchedulingConditionMetadata> & CellRendererParams;
 
   const dispatch = createEventDispatcher();
 
-  let filteredConditions: SchedulingCondition[] = [];
+  const baseColumnDefs: DataGridColumnDef<SchedulingConditionMetadata>[] = [
+    {
+      field: 'id',
+      filter: 'number',
+      headerName: 'ID',
+      resizable: true,
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 60,
+    },
+    { field: 'name', filter: 'text', headerName: 'Name', minWidth: 80, resizable: true, sortable: true },
+    {
+      field: 'owner',
+      filter: 'string',
+      headerName: 'Owner',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 80,
+    },
+    {
+      field: 'updated_by',
+      filter: 'string',
+      headerName: 'Updated By',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 120,
+    },
+    {
+      field: 'versions',
+      filter: 'string',
+      headerName: 'Latest Version',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      valueGetter: (params: ValueGetterParams<SchedulingConditionMetadata>) => {
+        return params?.data?.versions[params?.data?.versions.length - 1].revision;
+      },
+      width: 125,
+    },
+    {
+      autoHeight: true,
+      cellRenderer: tagsCellRenderer,
+      field: 'tags',
+      filter: 'text',
+      filterValueGetter: tagsFilterValueGetter,
+      headerName: 'Tags',
+      resizable: true,
+      sortable: false,
+      width: 220,
+      wrapText: true,
+    },
+  ];
+
+  const permissionError = 'You do not have permission to create Scheduling Conditions';
+
+  let columnDefs: DataGridColumnDef[] = baseColumnDefs;
+
+  let filteredConditions: SchedulingConditionMetadata[] = [];
   let filterText: string = '';
+  let hasPermission: boolean = false;
 
   $: filteredConditions = schedulingConditions.filter(condition => {
     const filterTextLowerCase = filterText.toLowerCase();
@@ -98,6 +99,7 @@
     const includesName = condition.name.toLocaleLowerCase().includes(filterTextLowerCase);
     return includesId || includesName;
   });
+  $: hasPermission = featurePermissions.schedulingConditions.canCreate(user);
   $: if (selectedCondition !== null) {
     const found = schedulingConditions.findIndex(condition => condition.id === selectedCondition?.id);
     if (found === -1) {
@@ -105,7 +107,49 @@
     }
   }
 
-  function deleteCondition({ id }: Pick<SchedulingCondition, 'id'>) {
+  $: columnDefs = [
+    ...baseColumnDefs,
+    {
+      cellClass: 'action-cell-container',
+      cellRenderer: (params: SchedulingConditionsCellRendererParams) => {
+        const actionsDiv = document.createElement('div');
+        actionsDiv.className = 'actions-cell';
+        new DataGridActions({
+          props: {
+            deleteCallback: params.deleteCondition,
+            deleteTooltip: {
+              content: 'Delete Condition',
+              placement: 'bottom',
+            },
+            editCallback: params.editCondition,
+            editTooltip: {
+              content: 'Edit Condition',
+              placement: 'bottom',
+            },
+            hasDeletePermission: params.data ? hasDeletePermission(params.data) : false,
+            hasEditPermission: params.data ? hasEditPermission(params.data) : false,
+            rowData: params.data,
+          },
+          target: actionsDiv,
+        });
+
+        return actionsDiv;
+      },
+      cellRendererParams: {
+        deleteCondition,
+        editCondition,
+      } as CellRendererParams,
+      field: 'actions',
+      headerName: '',
+      resizable: false,
+      sortable: false,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 55,
+    },
+  ];
+
+  function deleteCondition({ id }: Pick<SchedulingConditionMetadata, 'id'>) {
     dispatch('deleteCondition', id);
   }
 
@@ -113,7 +157,7 @@
     deleteCondition({ id: event.detail[0] as number });
   }
 
-  function editCondition({ id }: Pick<SchedulingCondition, 'id'>) {
+  function editCondition({ id }: Pick<SchedulingConditionMetadata, 'id'>) {
     goto(`${base}/scheduling/conditions/edit/${id}`);
   }
 
@@ -121,29 +165,15 @@
     editCondition({ id: event.detail[0] as number });
   }
 
-  function getPlanForCondition(condition: SchedulingCondition): PlanSchedulingSpec | null {
-    // If there is no spec id attached to the goal, the goal is not associated with a plan
-    let plan = null;
-    if (condition.scheduling_specification_conditions.length > 0) {
-      const specification_id = condition.scheduling_specification_conditions[0].specification_id;
-      plan = plans?.find(plan => plan.scheduling_specification?.id === specification_id) ?? null;
-    }
-    return plan;
-  }
-
-  function hasDeletePermission(condition: SchedulingCondition) {
-    return featurePermissions.schedulingConditions.canDelete(user, getPlanForCondition(condition), condition);
-  }
-
-  function hasEditPermission(condition: SchedulingCondition) {
-    return featurePermissions.schedulingConditions.canUpdate(user, getPlanForCondition(condition), condition);
+  function hasDeletePermission(condition: SchedulingConditionMetadata) {
+    return featurePermissions.schedulingConditions.canDelete(user, condition);
   }
 
-  function hasCreatePermission(user: User): boolean {
-    return plans?.some(plan => featurePermissions.schedulingConditions.canCreate(user, plan)) ?? false;
+  function hasEditPermission(condition: SchedulingConditionMetadata) {
+    return featurePermissions.schedulingConditions.canUpdate(user, condition);
   }
 
-  function rowSelected(event: CustomEvent<DataGridRowSelection<SchedulingCondition>>) {
+  function rowSelected(event: CustomEvent<DataGridRowSelection<SchedulingConditionMetadata>>) {
     dispatch('rowSelected', event.detail);
   }
 </script>
@@ -160,8 +190,8 @@
       <button
         class="st-button secondary ellipsis"
         use:permissionHandler={{
-          hasPermission: user ? hasCreatePermission(user) : false,
-          permissionError: 'You do not have permission to create Scheduling Conditions',
+          hasPermission,
+          permissionError,
         }}
         on:click={() => goto(`${base}/scheduling/conditions/new`)}
       >
diff --git a/src/components/scheduling/goals/SchedulingGoal.svelte b/src/components/scheduling/goals/SchedulingGoal.svelte
index c8a95fd990..bcf45373f9 100644
--- a/src/components/scheduling/goals/SchedulingGoal.svelte
+++ b/src/components/scheduling/goals/SchedulingGoal.svelte
@@ -4,35 +4,42 @@
   import { base } from '$app/paths';
   import CaretDownFillIcon from 'bootstrap-icons/icons/caret-down-fill.svg?component';
   import CaretUpFillIcon from 'bootstrap-icons/icons/caret-up-fill.svg?component';
-  import type { User } from '../../../types/app';
-  import type { Plan } from '../../../types/plan';
-  import type { SchedulingGoalSlim } from '../../../types/scheduling';
-  import effects from '../../../utilities/effects';
+  import { createEventDispatcher } from 'svelte';
+  import { PlanStatusMessages } from '../../../enums/planStatusMessages';
+  import { SearchParameters } from '../../../enums/searchParameters';
+  import type { SchedulingGoalMetadata, SchedulingGoalPlanSpecification } from '../../../types/scheduling';
+  import { getTarget } from '../../../utilities/generic';
   import { permissionHandler } from '../../../utilities/permissionHandler';
   import { tooltip } from '../../../utilities/tooltip';
   import Collapse from '../../Collapse.svelte';
-  import ContextMenuHeader from '../../context-menu/ContextMenuHeader.svelte';
   import ContextMenuItem from '../../context-menu/ContextMenuItem.svelte';
   import Input from '../../form/Input.svelte';
   import SchedulingGoalAnalysesActivities from './SchedulingGoalAnalysesActivities.svelte';
   import SchedulingGoalAnalysesBadge from './SchedulingGoalAnalysesBadge.svelte';
 
-  export let enabled: boolean;
-  export let goal: SchedulingGoalSlim;
-  export let plan: Plan | null;
-  export let priority: number;
-  export let specificationId: number;
-  export let simulateAfter: boolean = true;
-  export let user: User | null;
-  export let hasGoalEditPermission: boolean = false;
-  export let hasSpecEditPermission: boolean = false;
-  export let hasDeletePermission: boolean = false;
+  export let goal: SchedulingGoalMetadata;
+  export let goalPlanSpec: SchedulingGoalPlanSpecification;
+  export let hasEditPermission: boolean = false;
+  export let modelId: number | undefined;
   export let permissionError: string = '';
+  export let readOnly: boolean = false;
 
-  $: upButtonHidden = priority <= 0;
-  $: simulateGoal = simulateAfter; // Copied to local var to reflect changed values immediately in the UI
+  const dispatch = createEventDispatcher();
 
+  let enabled: boolean;
+  let priority: number;
+  let revisions: number[] = [];
   let schedulingGoalInput: HTMLInputElement;
+  let simulateGoal: boolean = false;
+  let upButtonHidden: boolean = false;
+
+  $: revisions = goal.versions.map(({ revision }) => revision).sort((revisionA, revisionB) => revisionB - revisionA);
+  $: {
+    enabled = goalPlanSpec.enabled;
+    priority = goalPlanSpec.priority;
+    upButtonHidden = priority <= 0;
+    simulateGoal = goalPlanSpec.simulate_after; // Copied to local var to reflect changed values immediately in the UI
+  }
 
   function focusInput() {
     if (document.activeElement !== schedulingGoalInput) {
@@ -42,10 +49,12 @@
     return true;
   }
 
-  function updatePriority(priority: number) {
-    if (plan) {
-      effects.updateSchedulingSpecGoal(goal.id, specificationId, { priority }, plan, user);
-    }
+  function onEnable(event: Event) {
+    const { value: enabled } = getTarget(event);
+    dispatch('updateGoalPlanSpec', {
+      ...goalPlanSpec,
+      enabled,
+    });
   }
 
   function onKeyDown(e: KeyboardEvent) {
@@ -61,10 +70,52 @@
       }
     }
   }
+
+  function onUpdateRevision(event: Event) {
+    const { value: revision } = getTarget(event);
+    dispatch('updateGoalPlanSpec', {
+      ...goalPlanSpec,
+      goal_revision: revision === '' ? null : parseInt(`${revision}`),
+    });
+  }
+
+  function simulateAfter(simulateAfter: boolean) {
+    dispatch('updateGoalPlanSpec', {
+      ...goalPlanSpec,
+      simulate_after: simulateAfter,
+    });
+  }
+
+  function updatePriority(priority: number) {
+    dispatch('updateGoalPlanSpec', {
+      ...goalPlanSpec,
+      priority,
+    });
+  }
 </script>
 
 <div class="scheduling-goal" class:disabled={!enabled}>
   <Collapse title={goal.name} tooltipContent={goal.name} defaultExpanded={false}>
+    <svelte:fragment slot="left">
+      <div class="left-content">
+        <input
+          type="checkbox"
+          checked={enabled}
+          style:cursor="pointer"
+          on:change={onEnable}
+          on:click|stopPropagation
+          use:permissionHandler={{
+            hasPermission: hasEditPermission,
+            permissionError,
+          }}
+          use:tooltip={{
+            content: `${enabled ? 'Disable goal' : 'Enable goal'} on plan`,
+            disabled: !hasEditPermission,
+            placement: 'top',
+          }}
+        />
+      </div>
+    </svelte:fragment>
     <svelte:fragment slot="right">
       <div class="right-content" role="none" on:click|stopPropagation>
         <SchedulingGoalAnalysesBadge analyses={goal.analyses} {enabled} />
@@ -80,11 +131,11 @@
             on:change={() => updatePriority(priority)}
             on:keydown={onKeyDown}
             use:permissionHandler={{
-              hasPermission: hasSpecEditPermission,
+              hasPermission: hasEditPermission,
               permissionError,
             }}
           />
-          {#if hasSpecEditPermission}
+          {#if hasEditPermission}
             <div class="priority-buttons">
               <button
                 use:tooltip={{ content: 'Increase Priority', placement: 'top' }}
@@ -104,64 +155,56 @@
               </button>
             </div>
           {/if}
-          <input
-            use:tooltip={{
-              content: hasSpecEditPermission ? (enabled ? 'Disable Scheduling Goal' : 'Enable Scheduling Goal') : '',
-              placement: 'top',
-            }}
-            bind:checked={enabled}
-            style:cursor="pointer"
-            type="checkbox"
-            on:change={() =>
-              plan && effects.updateSchedulingSpecGoal(goal.id, specificationId, { enabled }, plan, user)}
-            use:permissionHandler={{
-              hasPermission: hasSpecEditPermission,
-              permissionError,
-            }}
-          />
         </Input>
+        <select
+          class="st-select"
+          value={goalPlanSpec.goal_revision}
+          on:change={onUpdateRevision}
+          on:click|stopPropagation
+          use:permissionHandler={{
+            hasPermission: hasEditPermission,
+            permissionError: readOnly ? PlanStatusMessages.READ_ONLY : 'You do not have permission to edit plan goals',
+          }}
+        >
+          <option value={null}>Always use latest</option>
+          {#each revisions as revision, index}
+            <option value={revision}>{revision}{index === 0 ? ' (Latest)' : ''}</option>
+          {/each}
+        </select>
       </div>
     </svelte:fragment>
 
     <SchedulingGoalAnalysesActivities analyses={goal.analyses} />
 
     <svelte:fragment slot="contextMenuContent">
-      <ContextMenuHeader>Actions</ContextMenuHeader>
-      <ContextMenuItem
-        on:click={() => window.open(`${base}/scheduling/goals/edit/${goal.id}`, '_blank')}
-        use={[
-          [
-            permissionHandler,
-            {
-              hasPermission: hasGoalEditPermission,
-              permissionError,
-            },
-          ],
-        ]}
-      >
-        Edit Goal
-      </ContextMenuItem>
-      <ContextMenuHeader>Modify</ContextMenuHeader>
       <ContextMenuItem
-        on:click={() => plan && effects.deleteSchedulingGoal(goal, plan, user)}
+        on:click={() =>
+          window.open(
+            `${base}/scheduling/goals/edit/${goal.id}${
+              goalPlanSpec.goal_revision !== null
+                ? `?${SearchParameters.REVISION}=${goalPlanSpec.goal_revision}&${SearchParameters.MODEL_ID}=${modelId}`
+                : ''
+            }`,
+            '_blank',
+          )}
         use={[
           [
             permissionHandler,
             {
-              hasPermission: hasDeletePermission,
+              hasPermission: hasEditPermission,
               permissionError,
             },
           ],
         ]}
       >
-        Delete Goal
+        View Goal
       </ContextMenuItem>
       <ContextMenuItem
         use={[
           [
             permissionHandler,
             {
-              hasPermission: hasSpecEditPermission,
+              hasPermission: hasEditPermission,
               permissionError,
             },
           ],
@@ -172,9 +215,7 @@
           role="none"
           on:click|stopPropagation={() => {
             simulateGoal = !simulateGoal;
-            if (plan) {
-              effects.updateSchedulingSpecGoal(goal.id, specificationId, { simulate_after: simulateGoal }, plan, user);
-            }
+            simulateAfter(simulateGoal);
           }}
         >
           <input bind:checked={simulateGoal} style:cursor="pointer" type="checkbox" /> Simulate After
diff --git a/src/components/scheduling/goals/SchedulingGoalForm.svelte b/src/components/scheduling/goals/SchedulingGoalForm.svelte
index 55db31a32e..380879154a 100644
--- a/src/components/scheduling/goals/SchedulingGoalForm.svelte
+++ b/src/components/scheduling/goals/SchedulingGoalForm.svelte
@@ -3,404 +3,234 @@
 <script lang="ts">
   import { goto } from '$app/navigation';
   import { base } from '$app/paths';
-  import { schedulingGoalsColumns } from '../../../stores/scheduling';
-  import { tags } from '../../../stores/tags';
-  import type { User } from '../../../types/app';
-  import type { ModelSlim } from '../../../types/model';
-  import type { PlanSchedulingSpec } from '../../../types/plan';
-  import type { SchedulingGoal, SchedulingSpecGoalInsertInput } from '../../../types/scheduling';
-  import type { SchedulingGoalTagsInsertInput, Tag, TagsChangeEvent } from '../../../types/tags';
+  import { createEventDispatcher } from 'svelte';
+  import { SearchParameters } from '../../../enums/searchParameters';
+  import { schedulingGoals } from '../../../stores/scheduling';
+  import type { User, UserId } from '../../../types/app';
+  import type { TypeScriptFile } from '../../../types/monaco';
+  import type {
+    SchedulingGoalDefinitionTagsInsertInput,
+    SchedulingGoalMetadataTagsInsertInput,
+    Tag,
+  } from '../../../types/tags';
   import effects from '../../../utilities/effects';
-  import { isSaveEvent } from '../../../utilities/keyboardEvents';
-  import { showConfirmModal } from '../../../utilities/modal';
-  import { permissionHandler } from '../../../utilities/permissionHandler';
-  import { featurePermissions, isUserAdmin } from '../../../utilities/permissions';
-  import { diffTags } from '../../../utilities/tags';
-  import PageTitle from '../../app/PageTitle.svelte';
-  import CssGrid from '../../ui/CssGrid.svelte';
-  import CssGridGutter from '../../ui/CssGridGutter.svelte';
-  import Panel from '../../ui/Panel.svelte';
-  import SectionTitle from '../../ui/SectionTitle.svelte';
-  import TagsInput from '../../ui/Tags/TagsInput.svelte';
-  import SchedulingEditor from '../SchedulingEditor.svelte';
+  import { featurePermissions } from '../../../utilities/permissions';
+  import AssociationForm from '../../ui/Association/AssociationForm.svelte';
 
-  export let initialGoalAuthor: string | null = null;
-  export let initialGoalCreatedDate: string | null = null;
-  export let initialGoalDefinition: string = 'export default (): Goal => {\n\n}\n';
+  export let initialGoalDefinitionAuthor: UserId | undefined = undefined;
+  export let initialGoalDefinitionCode: string = 'export default (): GlobalSchedulingGoal => {\n\n}\n';
   export let initialGoalDescription: string = '';
   export let initialGoalId: number | null = null;
-  export let initialGoalModelId: number | null = null;
-  export let initialGoalModifiedDate: string | null = null;
   export let initialGoalName: string = '';
-  export let initialGoalTags: Tag[] = [];
-  export let initialSpecId: number | null = null;
+  export let initialGoalPublic: boolean = true;
+  export let initialGoalDefinitionTags: Tag[] = [];
+  export let initialGoalMetadataTags: Tag[] = [];
+  export let initialGoalOwner: UserId = null;
+  export let initialGoalRevision: number | null = null;
+  export let initialReferenceModelId: number | null = null;
+  export let goalRevisions: number[] = [];
+  export let tags: Tag[] = [];
   export let mode: 'create' | 'edit' = 'create';
-  export let plans: PlanSchedulingSpec[] = [];
-  export let models: ModelSlim[] = [];
   export let user: User | null;
 
-  const permissionError = 'You do not have permission to edit this scheduling goal.';
+  const dispatch = createEventDispatcher();
 
-  let goalAuthor: string | null = initialGoalAuthor;
-  let goalCreatedDate: string | null = initialGoalCreatedDate;
-  let goalDefinition: string = initialGoalDefinition;
-  let goalDescription: string = initialGoalDescription;
-  let goalId: number | null = initialGoalId;
-  let goalModelId: number | null = initialGoalModelId;
-  let goalModifiedDate: string | null = initialGoalModifiedDate;
-  let goalName: string = initialGoalName;
-  let goalTags: Tag[] = initialGoalTags;
-  let hasAuthoringPermission: boolean = false;
-  let hasPermission: boolean = false;
-  let saveButtonEnabled: boolean = false;
-  let specId: number | null = initialSpecId;
-  let savedSpecId: number | null = initialSpecId;
-  let savedGoal: Partial<SchedulingGoal> = {
-    definition: goalDefinition,
-    description: goalDescription,
-    name: goalName,
-    tags: goalTags.map(tag => ({ tag })),
-    ...(goalModelId !== null ? { model_id: goalModelId } : {}),
-  };
+  const permissionError = `You do not have permission to ${
+    mode === 'edit' ? 'edit this' : 'create a'
+  } scheduling goal.`;
 
-  $: planOptions = plans
-    .filter(plan => plan.model_id === goalModelId)
-    .map(({ scheduling_specification, ...plan }) => ({
-      ...plan,
-      specId: (scheduling_specification && scheduling_specification.id) || null,
-    }));
-  $: selectedPlan = planOptions.find(({ specId: planSpecId }) => planSpecId === specId);
-  $: specId = planOptions.some(plan => plan.specId === specId) ? specId : null; // Null the specId value if the filtered plan list no longer includes the chosen spec
-  $: saveButtonEnabled = goalDefinition !== '' && goalModelId !== null && goalName !== '' && specId !== null;
-  $: goalModified =
-    diffGoals(savedGoal, {
-      definition: goalDefinition,
-      description: goalDescription,
-      name: goalName,
-      tags: goalTags.map(tag => ({ tag })),
-      ...(goalModelId !== null ? { model_id: goalModelId } : {}),
-    }) || specId !== savedSpecId;
-  $: if (user) {
-    hasPermission = specId
-      ? hasPlanPermission(planOptions.find(plan => plan.specId === specId)?.id, mode, user)
-      : goalModelId
-      ? hasModelPermission(goalModelId, mode, user)
-      : hasAnyPlanPermission(mode, user);
-  }
-  $: hasAuthoringPermission = mode === 'edit' ? isUserAdmin(user) : true;
-  $: saveButtonText = mode === 'edit' && !goalModified ? 'Saved' : 'Save';
-  $: saveButtonClass = goalModified && saveButtonEnabled ? 'primary' : 'secondary';
-  $: pageTitle = mode === 'edit' ? 'Scheduling Goals' : 'New Scheduling Goal';
-  $: pageSubtitle = mode === 'edit' ? savedGoal.name : '';
+  let goalsTsFiles: TypeScriptFile[] = [];
+  let hasCreateDefinitionCodePermission: boolean = false;
+  let hasWriteMetadataPermission: boolean = false;
 
-  function hasModelPermission(modelId: number, mode: 'create' | 'edit', user: User | null): boolean {
-    const plansFromModel = plans.filter(plan => plan.model_id === modelId);
-    return plansFromModel.some(plan => {
-      return (
-        (mode === 'create' && featurePermissions.schedulingGoals.canCreate(user, plan)) ||
-        featurePermissions.schedulingGoals.canUpdate(user, plan)
-      );
-    });
+  $: hasCreateDefinitionCodePermission = featurePermissions.schedulingGoals.canCreate(user);
+  $: hasWriteMetadataPermission =
+    mode === 'create'
+      ? featurePermissions.schedulingGoals.canCreate(user)
+      : featurePermissions.schedulingGoals.canUpdate(user, { owner: initialGoalOwner });
+  $: selectReferenceModel(initialReferenceModelId);
+
+  function selectReferenceModel(modelId: number | null) {
+    if (modelId !== null) {
+      effects.getTsFilesScheduling(modelId, user).then(tsFiles => (goalsTsFiles = tsFiles));
+    } else {
+      goalsTsFiles = [];
+    }
   }
 
-  function hasAnyPlanPermission(mode: 'create' | 'edit', user: User | null): boolean {
-    return plans.some(plan => {
-      return mode === 'create'
-        ? featurePermissions.schedulingGoals.canCreate(user, plan)
-        : featurePermissions.schedulingGoals.canUpdate(user, plan);
-    });
+  function selectRevision(revision: number | string) {
+    dispatch('selectRevision', parseInt(`${revision}`));
   }
 
-  function hasPlanPermission(planId: number | undefined, mode: 'create' | 'edit', user: User | null): boolean {
-    const plan = plans.find(plan => plan.id === planId);
-    if (plan) {
-      return mode === 'create'
-        ? featurePermissions.schedulingGoals.canCreate(user, plan)
-        : featurePermissions.schedulingGoals.canUpdate(user, plan);
-    }
-    return false;
+  function onRevisionSelection(event: CustomEvent) {
+    const { detail } = event;
+
+    selectRevision(`${detail}`);
   }
 
-  function diffGoals(goalA: Partial<SchedulingGoal>, goalB: Partial<SchedulingGoal>) {
-    return Object.entries(goalA).some(([key, value]) => {
-      if (key === 'tags') {
-        return diffTags(
-          (goalA.tags || []).map(({ tag }) => tag),
-          (goalB.tags || []).map(({ tag }) => tag),
-        );
-      } else {
-        return goalB[key as keyof SchedulingGoal] !== value;
-      }
-    });
+  function onSelectReferenceModel(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    selectReferenceModel(modelId);
+    dispatch('selectReferenceModel', modelId);
   }
 
-  function onDidChangeModelContent(event: CustomEvent<{ value: string }>) {
-    const { detail } = event;
-    const { value } = detail;
-    goalDefinition = value;
+  function onClose() {
+    goto(`${base}/scheduling/goals`);
   }
 
-  function onKeydown(event: KeyboardEvent): void {
-    if (isSaveEvent(event)) {
-      event.preventDefault();
-      saveGoal();
+  async function onCreateGoal(
+    event: CustomEvent<{
+      definition: {
+        code: string;
+        tags: Tag[];
+      };
+      description: string;
+      name: string;
+      public: boolean;
+      tags: Tag[];
+    }>,
+  ) {
+    const {
+      detail: { definition, description, name, public: isPublic, tags },
+    } = event;
+
+    const newGoalId = await effects.createSchedulingGoal(
+      name,
+      isPublic,
+      tags.map(({ id }) => ({ tag_id: id })),
+      definition.code,
+      definition.tags.map(({ id }) => ({ tag_id: id })),
+      user,
+      description,
+    );
+
+    if (newGoalId !== null) {
+      goto(
+        `${base}/scheduling/goals/edit/${newGoalId}${
+          initialReferenceModelId !== null ? `?${SearchParameters.MODEL_ID}=${initialReferenceModelId}` : ''
+        }`,
+      );
     }
   }
 
-  async function onTagsInputChange(event: TagsChangeEvent) {
+  async function onCreateNewGoalDefinition(
+    event: CustomEvent<{
+      definitionCode: string;
+      definitionTags: Tag[];
+    }>,
+  ) {
     const {
-      detail: { tag, type },
+      detail: { definitionCode, definitionTags },
     } = event;
-    if (type === 'remove') {
-      goalTags = goalTags.filter(t => t.name !== tag.name);
-    } else if (type === 'create' || type === 'select') {
-      let tagsToAdd: Tag[] = [tag];
-      if (type === 'create') {
-        tagsToAdd = (await effects.createTags([{ color: tag.color, name: tag.name }], user)) || [];
+    if (initialGoalId !== null) {
+      const definition = await effects.createSchedulingGoalDefinition(
+        initialGoalId,
+        definitionCode,
+        definitionTags.map(({ id }) => ({ tag_id: id })),
+        user,
+      );
+
+      if (definition !== null) {
+        selectRevision(definition.revision);
       }
-      goalTags = goalTags.concat(tagsToAdd);
     }
   }
 
-  async function saveGoal() {
-    if (saveButtonEnabled && goalModelId !== null && selectedPlan) {
-      if (mode === 'create') {
-        const newGoal = await effects.createSchedulingGoal(
-          goalDefinition,
-          goalName,
-          goalModelId,
-          selectedPlan,
-          user,
-          goalDescription,
-        );
-
-        if (newGoal !== null && specId !== null) {
-          const { id: newGoalId } = newGoal;
-
-          const specGoalInsertInput: SchedulingSpecGoalInsertInput = {
-            enabled: true,
-            goal_id: newGoalId,
-            specification_id: specId,
-          };
-
-          await effects.createSchedulingSpecGoal(specGoalInsertInput, user);
-
-          // Associate new tags with expansion rule
-          const newSchedulingGoalRuleTags: SchedulingGoalTagsInsertInput[] = goalTags.map(({ id: tag_id }) => ({
-            goal_id: newGoalId,
-            tag_id,
-          }));
-          await effects.createSchedulingGoalTags(newSchedulingGoalRuleTags, user);
-
-          goto(`${base}/scheduling/goals/edit/${newGoalId}`);
-        }
-      } else if (mode === 'edit') {
-        if (goalId === null) {
-          return;
-        }
-        if (specId !== savedSpecId) {
-          const { confirm } = await showConfirmModal(
-            'Confirm',
-            'Updating the plan will reset the priority of this scheduling goal.',
-            'Updating Plan',
-            true,
-          );
-
-          if (!confirm) {
-            return;
-          }
-        }
-
-        const goal: Partial<SchedulingGoal> = {
-          definition: goalDefinition,
-          description: goalDescription,
-          ...(hasAuthoringPermission && goalModelId !== null ? { model_id: goalModelId } : {}),
-          name: goalName,
-        };
-        const updatedGoal = await effects.updateSchedulingGoal(goalId, goal, selectedPlan, user);
-        if (updatedGoal) {
-          if (specId !== savedSpecId && savedSpecId !== null && specId !== null) {
-            // If changing plans/specId, first delete existing scheduling_spec_goal record and re-insert a new one
-            // this is to allow the insert triggers to keep priorities in sync.
-            const deletedSchedulingSpecGoal = await effects.deleteSchedulingSpecGoal(goalId, savedSpecId, user);
-            if (deletedSchedulingSpecGoal) {
-              await effects.createSchedulingSpecGoal(
-                { enabled: true, goal_id: goalId, specification_id: specId },
-                user,
-              );
-              savedSpecId = specId;
-            }
-          }
-
-          // Associate new tags with scheduling goal
-          const newSchedulingGoalTags: SchedulingGoalTagsInsertInput[] = goalTags.map(({ id: tag_id }) => ({
-            goal_id: goalId as number,
-            tag_id,
-          }));
-          await effects.createSchedulingGoalTags(newSchedulingGoalTags, user);
-
-          // Disassociate old tags from constraint
-          const unusedTags = initialGoalTags.filter(tag => !goalTags.find(t => tag.id === t.id)).map(tag => tag.id);
-          await effects.deleteSchedulingGoalTags(unusedTags, user);
+  async function onSaveGoalMetadata(
+    event: CustomEvent<{
+      metadata: {
+        description: string;
+        name: string;
+        owner: UserId;
+        public: boolean;
+      };
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>,
+  ) {
+    if (initialGoalId !== null) {
+      const {
+        detail: {
+          metadata: { description, name, owner, public: isPublic },
+          tagIdsToDelete,
+          tagsToUpdate,
+        },
+      } = event;
+      const goalMetadataTagsToUpdate: SchedulingGoalMetadataTagsInsertInput[] = tagsToUpdate.map(({ id }) => ({
+        goal_id: initialGoalId as number,
+        tag_id: id,
+      }));
+
+      await effects.updateSchedulingGoalMetadata(
+        initialGoalId,
+        {
+          description,
+          name,
+          owner,
+          public: isPublic,
+        },
+        goalMetadataTagsToUpdate,
+        tagIdsToDelete,
+        initialGoalOwner,
+        user,
+      );
+    }
+  }
 
-          goalModifiedDate = updatedGoal.modified_date;
-          savedGoal = { ...goal, tags: goalTags.map(tag => ({ tag })) };
-        }
-      }
+  async function onSaveGoalDefinitionRevisionTags(
+    event: CustomEvent<{
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>,
+  ) {
+    if (initialGoalId !== null && initialGoalRevision !== null) {
+      const {
+        detail: { tagIdsToDelete, tagsToUpdate },
+      } = event;
+      // Associate new tags with goal definition version
+      const goalDefinitionTagsToUpdate: SchedulingGoalDefinitionTagsInsertInput[] = tagsToUpdate.map(({ id }) => ({
+        goal_id: initialGoalId as number,
+        goal_revision: initialGoalRevision as number,
+        tag_id: id,
+      }));
+      await effects.updateSchedulingGoalDefinitionTags(
+        initialGoalId,
+        initialGoalRevision,
+        goalDefinitionTagsToUpdate,
+        tagIdsToDelete,
+        user,
+      );
     }
   }
 </script>
 
-<svelte:window on:keydown={onKeydown} />
-
-<PageTitle subTitle={pageSubtitle} title={pageTitle} />
-
-<CssGrid bind:columns={$schedulingGoalsColumns}>
-  <Panel padBody={false}>
-    <svelte:fragment slot="header">
-      <SectionTitle>{mode === 'create' ? 'New Scheduling Goal' : 'Edit Scheduling Goal'}</SectionTitle>
-
-      <div class="right">
-        <button class="st-button secondary ellipsis" on:click={() => goto(`${base}/scheduling/goals`)}>
-          {mode === 'create' ? 'Cancel' : 'Close'}
-        </button>
-        <button
-          class="st-button {saveButtonClass} ellipsis"
-          disabled={!saveButtonEnabled}
-          on:click|stopPropagation={saveGoal}
-          use:permissionHandler={{
-            hasPermission,
-            permissionError,
-          }}
-        >
-          {saveButtonText}
-        </button>
-      </div>
-    </svelte:fragment>
-
-    <svelte:fragment slot="body">
-      {#if mode === 'edit'}
-        <fieldset>
-          <label for="goalId">Goal ID</label>
-          <input class="st-input w-100" disabled name="goalId" value={goalId} />
-        </fieldset>
-
-        <fieldset>
-          <label for="createdAt">Created At</label>
-          <input class="st-input w-100" disabled name="createdAt" value={goalCreatedDate} />
-        </fieldset>
-
-        <fieldset>
-          <label for="updatedAt">Updated At</label>
-          <input class="st-input w-100" disabled name="updatedAt" value={goalModifiedDate} />
-        </fieldset>
-
-        <fieldset>
-          <label for="author">Original Author</label>
-          <input class="st-input w-100" disabled name="author" value={goalAuthor} />
-        </fieldset>
-      {/if}
-
-      <fieldset>
-        <label for="model">Model</label>
-        <select
-          bind:value={goalModelId}
-          class="st-select w-100"
-          name="model"
-          use:permissionHandler={{
-            hasPermission: hasAnyPlanPermission(mode, user) && hasAuthoringPermission,
-            permissionError,
-          }}
-        >
-          <option value={null} />
-          {#each models as model}
-            <option value={model.id} disabled={!hasModelPermission(model.id, mode, user)}>
-              {model.name}
-              (Version: {model.version})
-            </option>
-          {/each}
-        </select>
-      </fieldset>
-
-      <fieldset>
-        <label for="plan">Plan</label>
-        <select
-          bind:value={specId}
-          class="st-select w-100"
-          name="plan"
-          use:permissionHandler={{
-            hasPermission: hasAnyPlanPermission(mode, user),
-            permissionError,
-          }}
-        >
-          <option value={null} />
-          {#each planOptions as plan}
-            <option value={plan.specId} disabled={plan.specId === null || !hasPlanPermission(plan.id, mode, user)}>
-              {plan.name} ({plan.id}) {#if plan.specId === null} (Missing Scheduling Specification) {/if}
-            </option>
-          {/each}
-        </select>
-      </fieldset>
-
-      <fieldset>
-        <label for="goal-name">Name</label>
-        <input
-          bind:value={goalName}
-          autocomplete="off"
-          class="st-input w-100"
-          name="goal-name"
-          placeholder="Enter Goal Name (required)"
-          required
-          use:permissionHandler={{
-            hasPermission,
-            permissionError,
-          }}
-        />
-      </fieldset>
-
-      <fieldset>
-        <label for="goal-description">Description</label>
-        <textarea
-          bind:value={goalDescription}
-          autocomplete="off"
-          class="st-input w-100"
-          name="goal-description"
-          placeholder="Enter Goal Description (optional)"
-          use:permissionHandler={{
-            hasPermission,
-            permissionError,
-          }}
-        />
-      </fieldset>
-
-      <fieldset>
-        <label for="tags">Tags</label>
-        <TagsInput
-          options={$tags}
-          selected={goalTags}
-          on:change={onTagsInputChange}
-          use={[
-            [
-              permissionHandler,
-              {
-                hasPermission,
-                permissionError,
-              },
-            ],
-          ]}
-        />
-      </fieldset>
-    </svelte:fragment>
-  </Panel>
-
-  <CssGridGutter track={1} type="column" />
-
-  <SchedulingEditor
-    scheduleItemDefinition={goalDefinition}
-    scheduleItemModelId={goalModelId}
-    title="{mode === 'create' ? 'New' : 'Edit'} Scheduling Goal - Definition Editor"
-    {user}
-    readOnly={!hasPermission}
-    on:didChangeModelContent={onDidChangeModelContent}
-  />
-</CssGrid>
+<AssociationForm
+  allMetadata={$schedulingGoals}
+  displayName="Scheduling Goal"
+  {hasCreateDefinitionCodePermission}
+  {hasWriteMetadataPermission}
+  initialDefinitionAuthor={initialGoalDefinitionAuthor}
+  initialDefinitionCode={initialGoalDefinitionCode}
+  initialDescription={initialGoalDescription}
+  initialId={initialGoalId}
+  initialName={initialGoalName}
+  initialPublic={initialGoalPublic}
+  initialDefinitionTags={initialGoalDefinitionTags}
+  initialMetadataTags={initialGoalMetadataTags}
+  initialOwner={initialGoalOwner}
+  initialRevision={initialGoalRevision}
+  {initialReferenceModelId}
+  {permissionError}
+  revisions={goalRevisions}
+  {tags}
+  tsFiles={goalsTsFiles}
+  {mode}
+  {user}
+  on:close={onClose}
+  on:createDefinition={onCreateNewGoalDefinition}
+  on:createMetadata={onCreateGoal}
+  on:updateDefinitionTags={onSaveGoalDefinitionRevisionTags}
+  on:updateMetadata={onSaveGoalMetadata}
+  on:selectRevision={onRevisionSelection}
+  on:selectReferenceModel={onSelectReferenceModel}
+/>
diff --git a/src/components/scheduling/goals/SchedulingGoalForm.svelte.test.ts b/src/components/scheduling/goals/SchedulingGoalForm.svelte.test.ts
index e67106e9a6..07c7e91ace 100644
--- a/src/components/scheduling/goals/SchedulingGoalForm.svelte.test.ts
+++ b/src/components/scheduling/goals/SchedulingGoalForm.svelte.test.ts
@@ -1,55 +1,17 @@
 import { cleanup, render } from '@testing-library/svelte';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { ModelSlim } from '../../../types/model';
-import type { PlanSchedulingSpec } from '../../../types/plan';
 import { ADMIN_ROLE } from '../../../utilities/permissions';
 import SchedulingGoalForm from './SchedulingGoalForm.svelte';
 
 vi.mock('$env/dynamic/public', () => import.meta.env); // https://github.com/sveltejs/kit/issues/8180
 
-const plans: PlanSchedulingSpec[] = [
-  {
-    collaborators: [],
-    id: 1,
-    model_id: 1,
-    name: 'Plan With Scheduling Spec',
-    owner: 'foo',
-    scheduling_specification: {
-      id: 1,
-    },
-  },
-  {
-    collaborators: [],
-    id: 2,
-    model_id: 1,
-    name: 'Plan Without Scheduling Spec',
-    owner: 'foo',
-    scheduling_specification: null,
-  },
-];
-
-const models: ModelSlim[] = [
-  {
-    created_at: '2023-02-16T00:00:00',
-    id: 1,
-    jar_id: 1,
-    name: 'BananaNation',
-    owner: 'bananafarmer',
-    plans: [],
-    version: '1.0.0',
-  },
-];
-
 describe('Scheduling Goal Form component', () => {
   afterEach(() => {
     cleanup();
   });
 
-  it('Should not assume all plans have a scheduling spec', () => {
+  it('Should no longer require plans for a shared scheduling spec', () => {
     const { container } = render(SchedulingGoalForm, {
-      initialGoalModelId: models[0].id,
-      models,
-      plans,
       user: {
         activeRole: ADMIN_ROLE,
         allowedRoles: [ADMIN_ROLE],
@@ -64,9 +26,6 @@ describe('Scheduling Goal Form component', () => {
     const planDropdown: HTMLSelectElement | null = container.querySelector('.st-select[name="plan"]');
 
     // Ensure the page and dropdown were rendered;
-    expect(planDropdown).to.exist;
-
-    // Ensure each plan is listed (plus one for empty option)
-    expect(planDropdown?.options.length).toEqual(plans.length + 1);
+    expect(planDropdown).not.to.exist;
   });
 });
diff --git a/src/components/scheduling/goals/SchedulingGoals.svelte b/src/components/scheduling/goals/SchedulingGoals.svelte
index ed857e4a93..bef0960c7d 100644
--- a/src/components/scheduling/goals/SchedulingGoals.svelte
+++ b/src/components/scheduling/goals/SchedulingGoals.svelte
@@ -3,14 +3,12 @@
 <script lang="ts">
   import { goto } from '$app/navigation';
   import { base } from '$app/paths';
-  import type { ICellRendererParams } from 'ag-grid-community';
+  import type { ICellRendererParams, ValueGetterParams } from 'ag-grid-community';
   import { createEventDispatcher } from 'svelte';
   import { tagsMap } from '../../../stores/tags';
   import type { User } from '../../../types/app';
   import type { DataGridColumnDef, DataGridRowSelection, RowId } from '../../../types/data-grid';
-  import type { PlanSchedulingSpec } from '../../../types/plan';
-  import type { SchedulingGoal, SchedulingGoalSlim } from '../../../types/scheduling';
-  import type { Tag } from '../../../types/tags';
+  import type { SchedulingGoalMetadata } from '../../../types/scheduling';
   import { permissionHandler } from '../../../utilities/permissionHandler';
   import { featurePermissions } from '../../../utilities/permissions';
   import Input from '../../form/Input.svelte';
@@ -20,121 +18,140 @@
   import Panel from '../../ui/Panel.svelte';
   import SectionTitle from '../../ui/SectionTitle.svelte';
 
-  export let schedulingGoals: SchedulingGoalSlim[] = [];
-  export let selectedGoal: SchedulingGoal | null | undefined = null;
+  export let schedulingGoals: SchedulingGoalMetadata[] = [];
+  export let selectedGoal: SchedulingGoalMetadata | null | undefined = null;
   export let user: User | null;
-  export let plans: PlanSchedulingSpec[] | null;
 
   type CellRendererParams = {
-    deleteGoal: (goal: SchedulingGoal) => void;
-    editGoal: (goal: SchedulingGoal) => void;
+    deleteGoal: (goal: SchedulingGoalMetadata) => void;
+    editGoal: (goal: SchedulingGoalMetadata) => void;
   };
-  type SchedulingGoalsCellRendererParams = ICellRendererParams<SchedulingGoal> & CellRendererParams;
-
-  let columnDefs: DataGridColumnDef[] = [];
-  $: if (user && plans) {
-    columnDefs = [
-      {
-        field: 'id',
-        filter: 'number',
-        headerName: 'ID',
-        resizable: true,
-        sortable: true,
-        suppressAutoSize: true,
-        suppressSizeToFit: true,
-        width: 60,
-      },
-      { field: 'name', filter: 'text', headerName: 'Name', resizable: true, sortable: true },
-      { field: 'model_id', filter: 'number', headerName: 'Model ID', sortable: true, width: 90 },
-      { field: 'author', filter: 'string', headerName: 'Author', sortable: true, width: 100 },
-      { field: 'last_modified_by', filter: 'string', headerName: 'Last Modified By', sortable: true, width: 100 },
-      { field: 'description', filter: 'string', headerName: 'Description', sortable: true, width: 120 },
-      {
-        autoHeight: true,
-        cellRenderer: tagsCellRenderer,
-        field: 'tags',
-        filter: 'text',
-        filterValueGetter: tagsFilterValueGetter,
-        headerName: 'Tags',
-        resizable: true,
-        sortable: false,
-        width: 220,
-        wrapText: true,
-      },
-      {
-        cellClass: 'action-cell-container',
-        cellRenderer: (params: SchedulingGoalsCellRendererParams) => {
-          const actionsDiv = document.createElement('div');
-          actionsDiv.className = 'actions-cell';
-          new DataGridActions({
-            props: {
-              deleteCallback: params.deleteGoal,
-              deleteTooltip: {
-                content: 'Delete Goal',
-                placement: 'bottom',
-              },
-              editCallback: params.editGoal,
-              editTooltip: {
-                content: 'Edit Goal',
-                placement: 'bottom',
-              },
-              hasDeletePermission: params.data ? hasDeletePermission(params.data) : false,
-              hasEditPermission: params.data ? hasEditPermission(params.data) : false,
-              rowData: params.data,
-            },
-            target: actionsDiv,
-          });
-
-          return actionsDiv;
-        },
-        cellRendererParams: {
-          deleteGoal,
-          editGoal,
-        } as CellRendererParams,
-        field: 'actions',
-        headerName: '',
-        resizable: false,
-        sortable: false,
-        suppressAutoSize: true,
-        suppressSizeToFit: true,
-        width: 55,
-      },
-    ];
-  }
+  type SchedulingGoalsCellRendererParams = ICellRendererParams<SchedulingGoalMetadata> & CellRendererParams;
 
   const dispatch = createEventDispatcher();
 
-  let filteredGoals: SchedulingGoal[] = [];
+  const baseColumnDefs: DataGridColumnDef<SchedulingGoalMetadata>[] = [
+    {
+      field: 'id',
+      filter: 'number',
+      headerName: 'ID',
+      resizable: true,
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 60,
+    },
+    { field: 'name', filter: 'text', headerName: 'Name', minWidth: 80, resizable: true, sortable: true },
+    {
+      field: 'owner',
+      filter: 'string',
+      headerName: 'Owner',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 80,
+    },
+    {
+      field: 'updated_by',
+      filter: 'string',
+      headerName: 'Updated By',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 120,
+    },
+    {
+      field: 'versions',
+      filter: 'string',
+      headerName: 'Latest Version',
+      sortable: true,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      valueGetter: (params: ValueGetterParams<SchedulingGoalMetadata>) => {
+        return params?.data?.versions[params?.data?.versions.length - 1].revision;
+      },
+      width: 125,
+    },
+    {
+      autoHeight: true,
+      cellRenderer: tagsCellRenderer,
+      field: 'tags',
+      filter: 'text',
+      filterValueGetter: tagsFilterValueGetter,
+      headerName: 'Tags',
+      resizable: true,
+      sortable: false,
+      width: 220,
+      wrapText: true,
+    },
+  ];
+
+  const permissionError = 'You do not have permission to create a scheduling goal.';
+
+  let columnDefs: DataGridColumnDef[] = baseColumnDefs;
+
+  let filteredGoals: SchedulingGoalMetadata[] = [];
   let filterText: string = '';
+  let hasPermission: boolean = false;
 
   $: if (schedulingGoals && $tagsMap) {
-    filteredGoals = schedulingGoals
-      .filter(goal => {
-        const filterTextLowerCase = filterText.toLowerCase();
-        const includesId = `${goal.id}`.includes(filterTextLowerCase);
-        const includesName = goal.name.toLocaleLowerCase().includes(filterTextLowerCase);
-        return includesId || includesName;
-      })
-      .map(goal => {
-        const matchingTags: { tag: Tag }[] = [];
-        goal.tags.forEach(({ tag_id }) => {
-          const matchingTag = $tagsMap[tag_id];
-          if (matchingTag) {
-            matchingTags.push({ tag: matchingTag });
-          }
-        });
-        const goalWithTags: SchedulingGoal = { ...goal, tags: matchingTags };
-        return goalWithTags;
-      });
+    filteredGoals = schedulingGoals.filter(goal => {
+      const filterTextLowerCase = filterText.toLowerCase();
+      const includesId = `${goal.id}`.includes(filterTextLowerCase);
+      const includesName = goal.name.toLocaleLowerCase().includes(filterTextLowerCase);
+      return includesId || includesName;
+    });
   }
+  $: hasPermission = featurePermissions.schedulingGoals.canCreate(user);
   $: if (selectedGoal !== null) {
     const found = schedulingGoals.findIndex(goal => goal.id === selectedGoal?.id);
     if (found === -1) {
       selectedGoal = null;
     }
   }
+  $: columnDefs = [
+    ...baseColumnDefs,
+    {
+      cellClass: 'action-cell-container',
+      cellRenderer: (params: SchedulingGoalsCellRendererParams) => {
+        const actionsDiv = document.createElement('div');
+        actionsDiv.className = 'actions-cell';
+        new DataGridActions({
+          props: {
+            deleteCallback: params.deleteGoal,
+            deleteTooltip: {
+              content: 'Delete Goal',
+              placement: 'bottom',
+            },
+            editCallback: params.editGoal,
+            editTooltip: {
+              content: 'Edit Goal',
+              placement: 'bottom',
+            },
+            hasDeletePermission: params.data ? hasDeletePermission(user, params.data) : false,
+            hasEditPermission: params.data ? hasEditPermission(user, params.data) : false,
+            rowData: params.data,
+          },
+          target: actionsDiv,
+        });
 
-  function deleteGoal({ id }: Pick<SchedulingGoal, 'id'>) {
+        return actionsDiv;
+      },
+      cellRendererParams: {
+        deleteGoal,
+        editGoal,
+      } as CellRendererParams,
+      field: 'actions',
+      headerName: '',
+      resizable: false,
+      sortable: false,
+      suppressAutoSize: true,
+      suppressSizeToFit: true,
+      width: 55,
+    },
+  ];
+
+  function deleteGoal({ id }: Pick<SchedulingGoalMetadata, 'id'>) {
     dispatch('deleteGoal', id);
   }
 
@@ -142,7 +159,7 @@
     deleteGoal({ id: event.detail[0] as number });
   }
 
-  function editGoal({ id }: Pick<SchedulingGoal, 'id'>) {
+  function editGoal({ id }: Pick<SchedulingGoalMetadata, 'id'>) {
     goto(`${base}/scheduling/goals/edit/${id}`);
   }
 
@@ -150,31 +167,15 @@
     editGoal({ id: event.detail[0] as number });
   }
 
-  function getPlanForGoal(goal: SchedulingGoal): PlanSchedulingSpec | null {
-    // If there is no spec id attached to the goal, the goal is not associated with a plan
-    let plan = null;
-    if (goal.scheduling_specification_goal) {
-      const {
-        scheduling_specification_goal: { specification_id },
-      } = goal;
-      plan = plans?.find(plan => plan.scheduling_specification?.id === specification_id) ?? null;
-    }
-    return plan;
-  }
-
-  function hasDeletePermission(goal: SchedulingGoal) {
-    return featurePermissions.schedulingGoals.canDelete(user, getPlanForGoal(goal), goal);
-  }
-
-  function hasEditPermission(goal: SchedulingGoal) {
-    return featurePermissions.schedulingGoals.canUpdate(user, getPlanForGoal(goal), goal);
+  function hasDeletePermission(user: User | null, goal: SchedulingGoalMetadata) {
+    return featurePermissions.schedulingGoals.canDelete(user, goal);
   }
 
-  function hasCreatePermission(user: User): boolean {
-    return plans?.some(plan => featurePermissions.schedulingGoals.canCreate(user, plan)) ?? false;
+  function hasEditPermission(user: User | null, goal: SchedulingGoalMetadata) {
+    return featurePermissions.schedulingGoals.canUpdate(user, goal);
   }
 
-  function rowSelected(event: CustomEvent<DataGridRowSelection<SchedulingGoal>>) {
+  function rowSelected(event: CustomEvent<DataGridRowSelection<SchedulingGoalMetadata>>) {
     dispatch('rowSelected', event.detail);
   }
 </script>
@@ -191,8 +192,8 @@
       <button
         class="st-button secondary ellipsis"
         use:permissionHandler={{
-          hasPermission: user ? hasCreatePermission(user) : false,
-          permissionError: 'You do not have permission to create Scheduling Goals',
+          hasPermission,
+          permissionError,
         }}
         on:click={() => goto(`${base}/scheduling/goals/new`)}
       >
diff --git a/src/components/sequencing/SequenceEditor.svelte b/src/components/sequencing/SequenceEditor.svelte
index 395b23fe30..387f65b177 100644
--- a/src/components/sequencing/SequenceEditor.svelte
+++ b/src/components/sequencing/SequenceEditor.svelte
@@ -29,7 +29,7 @@
   let commandDictionaryJson: AmpcsCommandDictionary | null = null;
   let commandDictionaryTsFiles: TypeScriptFile[] = [];
   let monaco: Monaco;
-  let editor: Editor.IStandaloneCodeEditor;
+  let worker: languages.typescript.TypeScriptWorker | null = null;
   let sequenceEditorModel: Editor.ITextModel;
 
   $: effects
@@ -55,8 +55,15 @@
     typescriptDefaults.setExtraLibs(commandDictionaryTsFiles);
   }
 
-  $: if (monaco !== undefined && commandDictionaryJson !== undefined) {
-    workerUpdateModel();
+  /**
+   * Used to update the custom worker to use the selected command dictionary.
+   */
+  $: if (worker != null && sequenceEditorModel) {
+    worker.updateModelConfig({
+      command_dict_str: JSON.stringify(commandDictionaryJson ?? {}),
+      model_id: sequenceEditorModel.id,
+      should_inject: true,
+    });
   }
 
   function downloadSeqJson() {
@@ -66,52 +73,15 @@
     a.click();
   }
 
-  function editorCreated(event: CustomEvent<Editor.IStandaloneCodeEditor>) {
-    editor = event.detail;
-  }
-
   function workerFullyLoaded(
-    event: CustomEvent<{ model: Editor.ITextModel; worker: languages.typescript.TypeScriptWorker }>,
+    event: CustomEvent<{
+      editor: Editor.IStandaloneCodeEditor;
+      model: Editor.ITextModel;
+      worker: languages.typescript.TypeScriptWorker;
+    }>,
   ) {
-    const { model, worker } = event.detail;
-    const model_id = model.id;
-
-    worker.updateModelConfig({
-      command_dict_str: JSON.stringify(commandDictionaryJson ?? {}),
-      model_id,
-      should_inject: true,
-    });
-  }
-
-  /**
-   * Used to update the custom worker to use the selected command dictionary.
-   */
-  async function workerUpdateModel() {
-    if (editor) {
-      try {
-        /**
-         * We don't have a way to check if the editor is initialized or not so it was throwing a "typescript not registered"
-         * error here. This is a hacky workaround to see if the editor is ready and we can load the typescript worker.
-         * :woozy:
-         *
-         * https://github.com/microsoft/monaco-editor/issues/115
-         */
-        editor.onDidScrollChange(async () => {
-          const tsWorker = await monaco.languages.typescript.getTypeScriptWorker();
-          const worker = await tsWorker();
-
-          if (commandDictionaryJson && sequenceEditorModel) {
-            worker.updateModelConfig({
-              command_dict_str: JSON.stringify(commandDictionaryJson ?? {}),
-              model_id: sequenceEditorModel.id,
-              should_inject: true,
-            });
-          }
-        });
-      } catch (reason) {
-        console.log('Failed to pass the command dictionary to the custom worker.', reason);
-      }
-    }
+    const { worker: eventWorker } = event.detail;
+    worker = eventWorker;
   }
 </script>
 
@@ -140,7 +110,6 @@
         tabSize={2}
         value={sequenceDefinition}
         on:didChangeModelContent
-        on:editor={editorCreated}
         on:fullyLoaded={workerFullyLoaded}
       />
     </svelte:fragment>
diff --git a/src/components/ui/Association/AssociationForm.svelte b/src/components/ui/Association/AssociationForm.svelte
new file mode 100644
index 0000000000..e076188afd
--- /dev/null
+++ b/src/components/ui/Association/AssociationForm.svelte
@@ -0,0 +1,574 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  type FormDefinition = $$Generic<BaseDefinition>;
+  type FormMetadata = $$Generic<BaseMetadata<FormDefinition>>;
+
+  // eslint-disable-next-line
+  interface $$Events extends ComponentEvents<SvelteComponent> {
+    close: CustomEvent;
+    createDefinition: CustomEvent<{
+      definitionCode: string;
+      definitionTags: Tag[];
+    }>;
+    createMetadata: CustomEvent<{
+      definition: {
+        code: string;
+        tags: Tag[];
+      };
+      description: string;
+      name: string;
+      public: boolean;
+      tags: Tag[];
+    }>;
+    selectReferenceModel: CustomEvent<number | null>;
+    selectRevision: CustomEvent<number>;
+    updateDefinitionTags: CustomEvent<{
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>;
+    updateMetadata: CustomEvent<{
+      metadata: {
+        description: string;
+        name: string;
+        owner: UserId;
+        public: boolean;
+      };
+      tagIdsToDelete: number[];
+      tagsToUpdate: Tag[];
+    }>;
+  }
+
+  import HideIcon from '@nasa-jpl/stellar/icons/visible_hide.svg?component';
+  import ShowIcon from '@nasa-jpl/stellar/icons/visible_show.svg?component';
+  import { SvelteComponent, createEventDispatcher, type ComponentEvents } from 'svelte';
+  import type { User, UserId } from '../../../types/app';
+  import type { BaseDefinition, BaseMetadata } from '../../../types/metadata';
+  import type { TypeScriptFile } from '../../../types/monaco';
+  import type { Tag, TagsChangeEvent } from '../../../types/tags';
+  import effects from '../../../utilities/effects';
+  import { getTarget } from '../../../utilities/generic';
+  import { permissionHandler } from '../../../utilities/permissionHandler';
+  import { diffTags } from '../../../utilities/tags';
+  import PageTitle from '../../app/PageTitle.svelte';
+  import CssGrid from '../CssGrid.svelte';
+  import CssGridGutter from '../CssGridGutter.svelte';
+  import Panel from '../Panel.svelte';
+  import RadioButton from '../RadioButtons/RadioButton.svelte';
+  import RadioButtons from '../RadioButtons/RadioButtons.svelte';
+  import SectionTitle from '../SectionTitle.svelte';
+  import TagsInput from '../Tags/TagsInput.svelte';
+  import DefinitionEditor from './DefinitionEditor.svelte';
+
+  type SavedMetadata = Pick<FormMetadata, 'description' | 'name' | 'owner' | 'public' | 'tags'>;
+  type SavedDefinition = Pick<FormDefinition, 'definition' | 'tags'>;
+
+  export let allMetadata: FormMetadata[] = [];
+  export let displayName: string = '';
+  export let formColumns: string = '1fr 3px 2fr';
+  export let hasCreateDefinitionCodePermission: boolean = false;
+  export let hasWriteMetadataPermission: boolean = false;
+  export let initialDefinitionAuthor: UserId | undefined = undefined;
+  export let initialDefinitionCode: string = 'export default ():  => {\n\n}\n';
+  export let initialDescription: string = '';
+  export let initialId: number | null = null;
+  export let initialName: string = '';
+  export let initialPublic: boolean = true;
+  export let initialDefinitionTags: Tag[] = [];
+  export let initialMetadataTags: Tag[] = [];
+  export let initialOwner: UserId = null;
+  export let initialRevision: number | null = null;
+  export let initialReferenceModelId: number | null = null;
+  export let permissionError: string = '';
+  export let revisions: number[] = [];
+  export let tags: Tag[] = [];
+  export let tsFiles: TypeScriptFile[] = [];
+  export let mode: 'create' | 'edit' = 'create';
+  export let user: User | null;
+
+  const dispatch = createEventDispatcher();
+
+  let defintionAuthor: UserId | null = initialDefinitionAuthor ?? user?.id ?? null;
+  let definitionCode: string = initialDefinitionCode;
+  let definitionTags: Tag[] = initialDefinitionTags;
+  let description: string = initialDescription;
+  let hasUpdateDefinitionPermission = false;
+  let metadataId: number | null = initialId;
+  let metadataTags: Tag[] = initialMetadataTags;
+  let name: string = initialName;
+  let nameError: string = '';
+  let owner: UserId = initialOwner ?? user?.id ?? null;
+  let isPublic: boolean = initialPublic;
+  let isDefinitionModified: boolean = false;
+  let isDefinitionDataModified: boolean = false;
+  let isMetadataModified: boolean = false;
+  let referenceModelId: number | null = initialReferenceModelId;
+  let saveButtonEnabled: boolean = false;
+  let saveButtonText: string = 'Save';
+
+  let prevMetadataTags: Tag[] = initialMetadataTags;
+  let prevDefinitionTags: Tag[] = initialDefinitionTags;
+
+  $: if (diffTags(prevMetadataTags, initialMetadataTags)) {
+    metadataTags = initialMetadataTags;
+    prevMetadataTags = initialMetadataTags;
+  }
+  $: defintionAuthor = initialDefinitionAuthor ?? user?.id ?? null;
+  $: definitionCode = initialDefinitionCode;
+  $: if (diffTags(prevDefinitionTags, initialDefinitionTags)) {
+    definitionTags = initialDefinitionTags;
+    prevDefinitionTags = initialDefinitionTags;
+  }
+
+  $: isMetadataModified = diffMetadata(
+    {
+      description: initialDescription,
+      name: initialName,
+      owner: initialOwner,
+      public: initialPublic,
+      tags: initialMetadataTags.map(tag => ({ tag })),
+    },
+    {
+      description,
+      name,
+      owner,
+      public: isPublic,
+      tags: metadataTags.map(tag => ({ tag })),
+    },
+  );
+  $: isDefinitionModified = diffDefinition({ definition: initialDefinitionCode }, { definition: definitionCode });
+  $: isDefinitionDataModified = diffTags(initialDefinitionTags || [], definitionTags);
+  $: hasUpdateDefinitionPermission = user?.id === defintionAuthor || user?.id === initialOwner || isDefinitionModified;
+  $: pageTitle = mode === 'edit' ? 's' : 'New ';
+  $: pageSubtitle = mode === 'edit' ? initialName : '';
+  $: referenceModelId = initialReferenceModelId;
+  $: saveButtonEnabled =
+    nameError === '' &&
+    owner !== '' &&
+    definitionCode !== '' &&
+    name !== '' &&
+    (isMetadataModified || isDefinitionDataModified || isDefinitionModified);
+  $: saveButtonClass = saveButtonEnabled ? 'primary' : 'secondary';
+  $: if (mode === 'edit' && (isMetadataModified || isDefinitionModified)) {
+    saveButtonText = 'Saved';
+    if ((isMetadataModified || isDefinitionDataModified) && !isDefinitionModified) {
+      saveButtonText = 'Save';
+    } else if (isDefinitionModified) {
+      saveButtonText = 'Save as new version';
+    }
+  } else {
+    saveButtonText = 'Save';
+  }
+  $: if (isPublic && name) {
+    const existingMetadata = allMetadata.find(
+      ({ name: metadataName, public: isPublic }) => name === metadataName && isPublic,
+    );
+    if (existingMetadata != null && existingMetadata.id !== metadataId) {
+      nameError = 'Name must be unique when public';
+    } else {
+      nameError = '';
+    }
+  } else {
+    nameError = '';
+  }
+
+  function diffMetadata(metadataA: SavedMetadata, metadataB: SavedMetadata) {
+    if (
+      metadataA.description !== metadataB.description ||
+      metadataA.name !== metadataB.name ||
+      metadataA.public !== metadataB.public ||
+      metadataA.owner !== metadataB.owner ||
+      diffTags(
+        (metadataA.tags || []).map(({ tag }) => tag),
+        (metadataB.tags || []).map(({ tag }) => tag),
+      )
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  function diffDefinition(
+    definitionA: Pick<SavedDefinition, 'definition'>,
+    definitionB: Pick<SavedDefinition, 'definition'>,
+  ) {
+    return definitionA.definition !== definitionB.definition;
+  }
+
+  function onDidChangeModelContent(event: CustomEvent<{ value: string }>) {
+    const { detail } = event;
+    const { value } = detail;
+    definitionCode = value;
+  }
+
+  async function onDefinitionTagsInputChange(event: TagsChangeEvent) {
+    const {
+      detail: { tag, type },
+    } = event;
+    if (type === 'remove') {
+      definitionTags = definitionTags.filter(t => t.name !== tag.name);
+    } else if (type === 'create' || type === 'select') {
+      let tagsToAdd: Tag[] = [tag];
+      if (type === 'create') {
+        tagsToAdd = (await effects.createTags([{ color: tag.color, name: tag.name }], user)) || [];
+      }
+      definitionTags = definitionTags.concat(tagsToAdd);
+    }
+  }
+
+  async function onMetadataTagsInputChange(event: TagsChangeEvent) {
+    const {
+      detail: { tag, type },
+    } = event;
+    if (type === 'remove') {
+      metadataTags = metadataTags.filter(t => t.name !== tag.name);
+    } else if (type === 'create' || type === 'select') {
+      let tagsToAdd: Tag[] = [tag];
+      if (type === 'create') {
+        tagsToAdd = (await effects.createTags([{ color: tag.color, name: tag.name }], user)) || [];
+      }
+      metadataTags = metadataTags.concat(tagsToAdd);
+    }
+  }
+
+  function onSetPublic(event: CustomEvent<{ id: 'public' | 'private' }>) {
+    const {
+      detail: { id },
+    } = event;
+
+    isPublic = id === 'public';
+  }
+
+  function selectRevision(revision: number | string) {
+    dispatch('selectRevision', parseInt(`${revision}`));
+  }
+
+  function onRevisionSelection(event: Event) {
+    const { value } = getTarget(event);
+
+    selectRevision(`${value}`);
+  }
+
+  function onClose() {
+    dispatch('close');
+  }
+
+  async function create() {
+    if (saveButtonEnabled) {
+      dispatch('createMetadata', {
+        definition: {
+          code: definitionCode,
+          tags: definitionTags,
+        },
+        description,
+        name,
+        public: isPublic,
+        tags: metadataTags,
+      });
+    }
+  }
+
+  async function createNewDefinition() {
+    if (saveButtonEnabled && metadataId !== null) {
+      dispatch('createDefinition', {
+        definitionCode,
+        definitionTags,
+      });
+    }
+  }
+
+  function onSelectReferenceModel(event: CustomEvent<number | null>) {
+    const { detail } = event;
+    referenceModelId = detail;
+    dispatch('selectReferenceModel', detail);
+  }
+
+  async function save() {
+    if (metadataId) {
+      if (isMetadataModified) {
+        await saveMetadata();
+      }
+      if (isDefinitionDataModified && !isDefinitionModified) {
+        await saveDefinitionRevisionTags();
+      } else if (isDefinitionModified) {
+        await createNewDefinition();
+      }
+    } else {
+      await create();
+    }
+  }
+
+  async function saveMetadata() {
+    if (metadataId !== null) {
+      // Disassociate old tags from metadata
+      const tagIdsToDelete = initialMetadataTags
+        .filter(({ id }) => !metadataTags.find(t => id === t.id))
+        .map(({ id }) => id);
+
+      dispatch('updateMetadata', {
+        metadata: {
+          description: description,
+          name: name,
+          owner: owner,
+          public: isPublic,
+        },
+        tagIdsToDelete,
+        tagsToUpdate: metadataTags,
+      });
+    }
+  }
+
+  async function saveDefinitionRevisionTags() {
+    if (metadataId !== null && initialRevision !== null) {
+      // Disassociate old tags from definition
+      const tagIdsToDelete = initialDefinitionTags
+        .filter(tag => !definitionTags.find(t => tag.id === t.id))
+        .map(tag => tag.id);
+
+      dispatch('updateDefinitionTags', {
+        tagIdsToDelete,
+        tagsToUpdate: definitionTags,
+      });
+    }
+  }
+
+  function revert() {
+    defintionAuthor = initialDefinitionAuthor ?? user?.id ?? null;
+    definitionCode = initialDefinitionCode;
+    definitionTags = initialDefinitionTags;
+    description = initialDescription;
+    metadataId = initialId;
+    metadataTags = initialMetadataTags;
+    name = initialName;
+    owner = initialOwner ?? user?.id ?? null;
+    isPublic = initialPublic;
+  }
+</script>
+
+<PageTitle subTitle={pageSubtitle} title={pageTitle} />
+
+<CssGrid bind:columns={formColumns}>
+  <Panel overflowYBody="hidden" padBody={false}>
+    <svelte:fragment slot="header">
+      <SectionTitle>{mode === 'create' ? `New ${displayName}` : `Edit ${displayName}`}</SectionTitle>
+
+      <div class="right">
+        <button class="st-button secondary ellipsis" on:click={onClose}>
+          {mode === 'create' ? 'Cancel' : 'Close'}
+        </button>
+        {#if mode === 'edit' && saveButtonEnabled}
+          <button class="st-button secondary ellipsis" on:click={revert}> Revert </button>
+        {/if}
+        <button
+          class="st-button {saveButtonClass} ellipsis"
+          disabled={!saveButtonEnabled}
+          use:permissionHandler={{
+            hasPermission: saveButtonEnabled,
+            permissionError,
+          }}
+          on:click={save}
+        >
+          {saveButtonText}
+        </button>
+      </div>
+    </svelte:fragment>
+
+    <svelte:fragment slot="body">
+      <fieldset>
+        <label for="metadata-name">Name</label>
+        <input
+          bind:value={name}
+          autocomplete="off"
+          class:metadata-form-error={!!nameError}
+          class="st-input w-100"
+          name="metadata-name"
+          placeholder={`Enter ${displayName} Name (required)`}
+          required
+          use:permissionHandler={{
+            hasPermission: hasWriteMetadataPermission,
+            permissionError,
+          }}
+        />
+        <div class="metadata-form-error-message">{nameError}</div>
+      </fieldset>
+
+      <fieldset>
+        <label for="owner">Owner</label>
+        <input
+          bind:value={owner}
+          class="st-input w-100"
+          name="owner"
+          placeholder={`Enter ${displayName} Owner Username (required)`}
+          use:permissionHandler={{
+            hasPermission: hasWriteMetadataPermission,
+            permissionError,
+          }}
+        />
+      </fieldset>
+
+      <fieldset>
+        <label for="metadata-description">Description</label>
+        <textarea
+          bind:value={description}
+          autocomplete="off"
+          class="st-input w-100"
+          name="metadata-description"
+          placeholder={`Enter ${displayName} Description (optional)`}
+          use:permissionHandler={{
+            hasPermission: hasWriteMetadataPermission,
+            permissionError,
+          }}
+        />
+      </fieldset>
+
+      <fieldset>
+        <label for="metadataTags">Tags</label>
+        <TagsInput
+          name="metadataTags"
+          use={[
+            [
+              permissionHandler,
+              {
+                hasPermission: hasWriteMetadataPermission,
+                permissionError,
+              },
+            ],
+          ]}
+          options={tags}
+          selected={metadataTags}
+          on:change={onMetadataTagsInputChange}
+        />
+      </fieldset>
+
+      {#if mode === 'edit'}
+        <fieldset>
+          <label for="id">{displayName} ID</label>
+          <input class="st-input w-100" disabled name="id" value={metadataId} />
+        </fieldset>
+      {/if}
+
+      <fieldset>
+        <label for="public">Visibility</label>
+        <RadioButtons selectedButtonId={isPublic ? 'public' : 'private'} on:select-radio-button={onSetPublic}>
+          <RadioButton
+            id="private"
+            use={[
+              [
+                permissionHandler,
+                {
+                  hasPermission: hasWriteMetadataPermission,
+                  permissionError,
+                },
+              ],
+            ]}><div class="public-button"><HideIcon /><span>Private</span></div></RadioButton
+          >
+          <RadioButton
+            id="public"
+            use={[
+              [
+                permissionHandler,
+                {
+                  hasPermission: hasWriteMetadataPermission,
+                  permissionError,
+                },
+              ],
+            ]}><div class="public-button"><ShowIcon /><span>Public</span></div></RadioButton
+          >
+        </RadioButtons>
+      </fieldset>
+
+      <div class="definition-divider" />
+
+      {#if mode === 'edit'}
+        <fieldset>
+          <label for="versions">Version</label>
+          {#if !isDefinitionModified}
+            <select value={initialRevision} class="st-select w-100" name="versions" on:change={onRevisionSelection}>
+              {#each revisions as revision}
+                <option value={revision}>
+                  {revision}
+                </option>
+              {/each}
+            </select>
+          {:else}
+            <select disabled class="st-select w-100" name="versions">
+              <option value={revisions[revisions.length - 1] + 1}>
+                {revisions[revisions.length - 1] + 1} (Next version)
+              </option>
+            </select>
+          {/if}
+        </fieldset>
+      {/if}
+
+      <fieldset>
+        <label for="definitionAuthor">Author</label>
+        <input
+          disabled
+          value={defintionAuthor}
+          class="st-input w-100"
+          name="definitionAuthor"
+          use:permissionHandler={{
+            hasPermission: hasWriteMetadataPermission,
+            permissionError,
+          }}
+        />
+      </fieldset>
+
+      <fieldset>
+        <label for="definitionTags">Version Tags</label>
+        <TagsInput
+          name="definitionTags"
+          use={[
+            [
+              permissionHandler,
+              {
+                hasPermission: hasUpdateDefinitionPermission,
+                permissionError,
+              },
+            ],
+          ]}
+          options={tags}
+          selected={definitionTags}
+          on:change={onDefinitionTagsInputChange}
+        />
+      </fieldset>
+    </svelte:fragment>
+  </Panel>
+
+  <CssGridGutter track={1} type="column" />
+
+  <DefinitionEditor
+    definition={definitionCode}
+    {referenceModelId}
+    readOnly={!hasCreateDefinitionCodePermission}
+    {tsFiles}
+    title={`${mode === 'create' ? 'New' : 'Edit'} ${displayName} - Definition Editor`}
+    on:didChangeModelContent={onDidChangeModelContent}
+    on:selectReferenceModel={onSelectReferenceModel}
+  />
+</CssGrid>
+
+<style>
+  .public-button {
+    column-gap: 0.3rem;
+    display: grid;
+    grid-template-columns: min-content min-content;
+  }
+
+  .definition-divider {
+    border-top: 1px solid var(--st-gray-20);
+    display: grid;
+    margin: 2rem 1rem;
+  }
+
+  .metadata-form-error {
+    border-color: var(--st-error-red);
+    color: var(--st-error-red);
+  }
+
+  .metadata-form-error-message {
+    color: var(--st-error-red);
+    margin: 0.25rem;
+  }
+</style>
diff --git a/src/components/constraints/ConstraintEditor.svelte b/src/components/ui/Association/DefinitionEditor.svelte
similarity index 63%
rename from src/components/constraints/ConstraintEditor.svelte
rename to src/components/ui/Association/DefinitionEditor.svelte
index a3e6a140e8..ba956d61e8 100644
--- a/src/components/constraints/ConstraintEditor.svelte
+++ b/src/components/ui/Association/DefinitionEditor.svelte
@@ -1,28 +1,27 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
+  import type { editor as Editor, languages } from 'monaco-editor/esm/vs/editor/editor.api';
   import { createEventDispatcher } from 'svelte';
-  import { models } from '../../stores/plan';
-  import type { User } from '../../types/app';
-  import type { DropdownOptions, SelectedDropdownOptionValue } from '../../types/dropdown';
-  import type { Monaco, TypeScriptFile } from '../../types/monaco';
-  import effects from '../../utilities/effects';
-  import MonacoEditor from '../ui/MonacoEditor.svelte';
-  import Panel from '../ui/Panel.svelte';
-  import SearchableDropdown from '../ui/SearchableDropdown.svelte';
-  import SectionTitle from '../ui/SectionTitle.svelte';
+  import { models } from '../../../stores/plan';
+  import type { DropdownOptions, SelectedDropdownOptionValue } from '../../../types/dropdown';
+  import type { Monaco, TypeScriptFile } from '../../../types/monaco';
+  import MonacoEditor from '../../ui/MonacoEditor.svelte';
+  import Panel from '../../ui/Panel.svelte';
+  import SearchableDropdown from '../../ui/SearchableDropdown.svelte';
+  import SectionTitle from '../../ui/SectionTitle.svelte';
 
-  export let constraintDefinition: string = '';
+  export let tsFiles: TypeScriptFile[] = [];
+  export let definition: string = '';
   export let referenceModelId: number | null = null;
   export let readOnly: boolean = false;
   export let title: string = 'Constraint - Definition Editor';
-  export let user: User | null;
 
   const dispatch = createEventDispatcher();
 
-  let constraintsTsFiles: TypeScriptFile[];
   let modelOptions: DropdownOptions = [];
   let monaco: Monaco;
+  let worker: languages.typescript.TypeScriptWorker | null = null;
 
   $: modelOptions = $models.map(({ id, name, version }) => ({
     display: `${name} (Version: ${version})`,
@@ -30,20 +29,31 @@
     value: id,
   }));
 
-  $: if (referenceModelId !== null) {
-    effects.getTsFilesConstraints(referenceModelId, user).then(tsFiles => (constraintsTsFiles = tsFiles));
-  } else {
-    constraintsTsFiles = [];
-  }
-
-  $: if (monaco !== undefined && constraintsTsFiles !== undefined) {
+  $: if (monaco !== undefined) {
     const { languages } = monaco;
     const { typescript } = languages;
     const { typescriptDefaults } = typescript;
     const options = typescriptDefaults.getCompilerOptions();
 
     typescriptDefaults.setCompilerOptions({ ...options, lib: ['esnext'], strictNullChecks: true });
-    typescriptDefaults.setExtraLibs(constraintsTsFiles);
+  }
+
+  $: if (monaco !== undefined && tsFiles !== undefined && worker != null) {
+    const { languages } = monaco;
+    const { typescript } = languages;
+    const { typescriptDefaults } = typescript;
+    typescriptDefaults.setExtraLibs(tsFiles);
+  }
+
+  function workerFullyLoaded(
+    event: CustomEvent<{
+      editor: Editor.IStandaloneCodeEditor;
+      model: Editor.ITextModel;
+      worker: languages.typescript.TypeScriptWorker;
+    }>,
+  ) {
+    const { worker: eventWorker } = event.detail;
+    worker = eventWorker;
   }
 
   function onSelectReferenceModel(event: CustomEvent<SelectedDropdownOptionValue>) {
@@ -80,8 +90,9 @@
       {readOnly}
       scrollBeyondLastLine={false}
       tabSize={2}
-      value={constraintDefinition}
+      value={definition}
       on:didChangeModelContent
+      on:fullyLoaded={workerFullyLoaded}
     />
   </svelte:fragment>
 </Panel>
diff --git a/src/components/ui/MonacoEditor.svelte b/src/components/ui/MonacoEditor.svelte
index 4853b14a6e..8b32016e69 100644
--- a/src/components/ui/MonacoEditor.svelte
+++ b/src/components/ui/MonacoEditor.svelte
@@ -48,8 +48,7 @@
 
   const dispatch = createEventDispatcher<{
     didChangeModelContent: { e: Editor.IModelContentChangedEvent; value: string };
-    editor: Editor.IStandaloneCodeEditor;
-    fullyLoaded: { model: Editor.ITextModel; worker: TypeScriptWorker };
+    fullyLoaded: { editor: Editor.IStandaloneCodeEditor; model: Editor.ITextModel; worker: TypeScriptWorker };
   }>();
 
   let className: string = '';
@@ -103,8 +102,6 @@
     monaco = await import('monaco-editor');
     editor = monaco.editor.create(div, options, override);
 
-    dispatch('editor', editor);
-
     if (language && language === 'typescript') {
       monaco.languages.typescript.typescriptDefaults.setWorkerOptions({
         customWorkerPath: `${base}/customTS.worker.js`,
@@ -146,8 +143,14 @@
 
           // Errors in the dispatch won't trigger the retry and will just fail.
           model = editor?.getModel(); // Set here so parents can bind to the model easily.
-          if (model != null && tsWorker !== null) {
-            dispatch('fullyLoaded', { model, worker: tsWorker });
+          if (editor != null && model != null && tsWorker !== null) {
+            dispatch('fullyLoaded', { editor, model, worker: tsWorker });
+            // Manually trigger a change in the editor to evaluate the source on load
+            // Will highlight errors on load without the user having to input something in the editor
+            if (!readOnly) {
+              editor.trigger('', 'type', { text: ' ' });
+              editor.trigger('', 'deleteLeft', {});
+            }
           }
         },
         5,
diff --git a/src/routes/constraints/edit/[id]/+page.svelte b/src/routes/constraints/edit/[id]/+page.svelte
index 0183d124f0..a159cc9be6 100644
--- a/src/routes/constraints/edit/[id]/+page.svelte
+++ b/src/routes/constraints/edit/[id]/+page.svelte
@@ -62,7 +62,7 @@
     }
   }
 
-  function onModelSelect(event: CustomEvent<number>) {
+  function onModelSelect(event: CustomEvent<number | null>) {
     const { detail: modelId } = event;
     if (browser) {
       setQueryParam(SearchParameters.MODEL_ID, modelId != null ? `${modelId}` : null);
diff --git a/src/routes/constraints/new/+page.svelte b/src/routes/constraints/new/+page.svelte
index b7508ba56d..d18160fa7d 100644
--- a/src/routes/constraints/new/+page.svelte
+++ b/src/routes/constraints/new/+page.svelte
@@ -13,6 +13,11 @@
 
   let referenceModelId: number | null = null;
 
+  function onModelSelect(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    referenceModelId = modelId;
+  }
+
   onMount(() => {
     if (browser) {
       const modelId = getSearchParameterNumber(SearchParameters.MODEL_ID) ?? null;
@@ -21,4 +26,10 @@
   });
 </script>
 
-<ConstraintForm initialReferenceModelId={referenceModelId} tags={$tags} mode="create" user={data.user} />
+<ConstraintForm
+  initialReferenceModelId={referenceModelId}
+  tags={$tags}
+  mode="create"
+  user={data.user}
+  on:selectReferenceModel={onModelSelect}
+/>
diff --git a/src/routes/plans/[id]/+page.svelte b/src/routes/plans/[id]/+page.svelte
index 6a616719b4..3dddfb149a 100644
--- a/src/routes/plans/[id]/+page.svelte
+++ b/src/routes/plans/[id]/+page.svelte
@@ -222,7 +222,7 @@
     hasExpandPermission =
       featurePermissions.expansionSequences.canExpand(data.user, $plan, $plan.model) && !$planReadOnly;
     hasScheduleAnalysisPermission =
-      featurePermissions.schedulingGoals.canAnalyze(data.user, $plan, $plan.model) && !$planReadOnly;
+      featurePermissions.schedulingGoalsPlanSpec.canAnalyze(data.user, $plan, $plan.model) && !$planReadOnly;
     hasSimulatePermission = featurePermissions.simulation.canRun(data.user, $plan, $plan.model) && !$planReadOnly;
   }
   $: if (data.initialPlan) {
diff --git a/src/routes/plans/[id]/+page.ts b/src/routes/plans/[id]/+page.ts
index e3a4d0aa55..323a676f10 100644
--- a/src/routes/plans/[id]/+page.ts
+++ b/src/routes/plans/[id]/+page.ts
@@ -23,7 +23,7 @@ export const load: PageLoad = async ({ parent, params, url }) => {
       // if plan doesn't have a scheduling spec, create one at this point
       if (!initialPlan.scheduling_specification) {
         const { start_time_doy, end_time_doy, revision } = initialPlan;
-        const schedulingSpec = await effects.createSchedulingSpec(
+        const schedulingSpec = await effects.createSchedulingPlanSpecification(
           {
             analysis_only: false,
             horizon_end: end_time_doy,
diff --git a/src/routes/scheduling/+page.svelte b/src/routes/scheduling/+page.svelte
index bae7fffdaf..a7fa579c8c 100644
--- a/src/routes/scheduling/+page.svelte
+++ b/src/routes/scheduling/+page.svelte
@@ -10,4 +10,4 @@
 
 <PageTitle title="Scheduling" />
 
-<Scheduling plans={data.plans} user={data.user} />
+<Scheduling user={data.user} />
diff --git a/src/routes/scheduling/+page.ts b/src/routes/scheduling/+page.ts
index 856c82604f..ee8329053d 100644
--- a/src/routes/scheduling/+page.ts
+++ b/src/routes/scheduling/+page.ts
@@ -1,14 +1,9 @@
-import effects from '../../utilities/effects';
 import type { PageLoad } from './$types';
 
 export const load: PageLoad = async ({ parent }) => {
   const { user } = await parent();
 
-  const { models = [], plans = [] } = await effects.getPlansAndModelsForScheduling(user);
-
   return {
-    models,
-    plans,
     user,
   };
 };
diff --git a/src/routes/scheduling/conditions/edit/[id]/+page.svelte b/src/routes/scheduling/conditions/edit/[id]/+page.svelte
index b24255c8a0..a36ca8d2b5 100644
--- a/src/routes/scheduling/conditions/edit/[id]/+page.svelte
+++ b/src/routes/scheduling/conditions/edit/[id]/+page.svelte
@@ -1,27 +1,104 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
+  import { browser } from '$app/environment';
+  import { page } from '$app/stores';
+  import { onMount } from 'svelte';
   import PageTitle from '../../../../../components/app/PageTitle.svelte';
   import SchedulingConditionForm from '../../../../../components/scheduling/conditions/SchedulingConditionForm.svelte';
+  import { SearchParameters } from '../../../../../enums/searchParameters';
+  import { schedulingConditionMetadata, schedulingConditionMetadataId } from '../../../../../stores/scheduling';
+  import { tags } from '../../../../../stores/tags';
+  import type {
+    SchedulingConditionDefinition,
+    SchedulingConditionMetadataVersionDefinition,
+  } from '../../../../../types/scheduling';
+  import { getSearchParameterNumber, setQueryParam } from '../../../../../utilities/generic';
   import type { PageData } from './$types';
 
   export let data: PageData;
+
+  let conditionRevision: number =
+    getSearchParameterNumber(SearchParameters.REVISION, $page.url.searchParams) ??
+    data.initialCondition.versions[data.initialCondition.versions.length - 1].revision;
+
+  let conditionDefinition: Pick<SchedulingConditionDefinition, 'author' | 'definition' | 'revision' | 'tags'> =
+    data.initialCondition.versions.find(
+      ({ revision }) => revision === conditionRevision,
+    ) as SchedulingConditionMetadataVersionDefinition;
+  let conditionDefinitionCode = conditionDefinition?.definition;
+  let conditionDefinitionAuthor = conditionDefinition?.author;
+  let conditionDescription = data.initialCondition.description;
+  let conditionId = data.initialCondition.id;
+  let conditionName = data.initialCondition.name;
+  let conditionPublic = data.initialCondition.public;
+  let conditionDefinitionTags = conditionDefinition.tags.map(({ tag }) => tag);
+  let conditionMetadataTags = data.initialCondition.tags.map(({ tag }) => tag);
+  let conditionOwner = data.initialCondition.owner;
+  let conditionRevisions = data.initialCondition.versions.map(({ revision }) => revision);
+  let referenceModelId: number | null = null;
+
+  $: $schedulingConditionMetadataId = data.initialCondition.id;
+  $: if ($schedulingConditionMetadata != null && $schedulingConditionMetadata.id === $schedulingConditionMetadataId) {
+    conditionDefinition = $schedulingConditionMetadata.versions.find(
+      ({ revision }) => revision === conditionRevision,
+    ) as SchedulingConditionMetadataVersionDefinition;
+    if (conditionDefinition != null) {
+      conditionDefinitionAuthor = conditionDefinition?.author;
+      conditionDefinitionCode = conditionDefinition?.definition;
+      conditionDefinitionTags = conditionDefinition?.tags.map(({ tag }) => tag);
+    }
+
+    conditionDescription = $schedulingConditionMetadata.description;
+    conditionId = $schedulingConditionMetadata.id;
+    conditionName = $schedulingConditionMetadata.name;
+    conditionPublic = $schedulingConditionMetadata.public;
+    conditionMetadataTags = $schedulingConditionMetadata.tags.map(({ tag }) => tag);
+    conditionOwner = $schedulingConditionMetadata.owner;
+    conditionRevisions = $schedulingConditionMetadata.versions.map(({ revision }) => revision);
+  }
+
+  function onRevisionSelect(event: CustomEvent<number>) {
+    const { detail: revision } = event;
+    conditionRevision = revision;
+    if (browser) {
+      setQueryParam(SearchParameters.REVISION, `${conditionRevision}`);
+    }
+  }
+
+  function onModelSelect(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    if (browser) {
+      setQueryParam(SearchParameters.MODEL_ID, modelId != null ? `${modelId}` : null);
+    }
+  }
+
+  onMount(() => {
+    if (browser) {
+      const modelId = getSearchParameterNumber(SearchParameters.MODEL_ID) ?? null;
+      referenceModelId = modelId;
+    }
+  });
 </script>
 
 <PageTitle subTitle={data.initialCondition.name} title="Scheduling Conditions" />
 
 <SchedulingConditionForm
-  initialConditionAuthor={data.initialCondition.author}
-  initialConditionCreatedDate={data.initialCondition.created_date}
-  initialConditionDefinition={data.initialCondition.definition}
-  initialConditionDescription={data.initialCondition.description}
-  initialConditionId={data.initialCondition.id}
-  initialConditionName={data.initialCondition.name}
-  initialConditionModelId={data.initialCondition.model_id}
-  initialConditionModifiedDate={data.initialCondition.modified_date}
-  initialSpecId={data.initialSpecId}
-  models={data.models}
-  plans={data.plans}
+  initialConditionDefinitionAuthor={conditionDefinitionAuthor}
+  initialConditionDefinitionCode={conditionDefinitionCode}
+  initialConditionDescription={conditionDescription}
+  initialConditionId={conditionId}
+  initialConditionName={conditionName}
+  initialConditionPublic={conditionPublic}
+  initialConditionDefinitionTags={conditionDefinitionTags}
+  initialConditionMetadataTags={conditionMetadataTags}
+  initialConditionOwner={conditionOwner}
+  initialConditionRevision={conditionRevision}
+  initialReferenceModelId={referenceModelId}
+  {conditionRevisions}
+  tags={$tags}
   mode="edit"
   user={data.user}
+  on:selectRevision={onRevisionSelect}
+  on:selectReferenceModel={onModelSelect}
 />
diff --git a/src/routes/scheduling/conditions/edit/[id]/+page.ts b/src/routes/scheduling/conditions/edit/[id]/+page.ts
index 6d40e30335..e9682b125c 100644
--- a/src/routes/scheduling/conditions/edit/[id]/+page.ts
+++ b/src/routes/scheduling/conditions/edit/[id]/+page.ts
@@ -8,21 +8,18 @@ export const load: PageLoad = async ({ parent, params }) => {
   const { user } = await parent();
 
   const { id: conditionIdParam } = params;
-  const { models = [], plans = [] } = await effects.getPlansAndModelsForScheduling(user);
 
   if (conditionIdParam !== null && conditionIdParam !== undefined) {
     const conditionId = parseFloatOrNull(conditionIdParam);
-    const initialCondition = await effects.getSchedulingCondition(conditionId, user);
-    const schedulingSpecConditions = await effects.getSchedulingSpecConditionsForCondition(conditionId, user);
 
-    if (initialCondition !== null) {
-      return {
-        initialCondition,
-        initialSpecId: schedulingSpecConditions?.[0]?.specification_id,
-        models,
-        plans,
-        user,
-      };
+    if (conditionId !== null) {
+      const initialCondition = await effects.getSchedulingCondition(conditionId, user);
+      if (initialCondition !== null) {
+        return {
+          initialCondition,
+          user,
+        };
+      }
     }
   }
 
diff --git a/src/routes/scheduling/conditions/new/+page.svelte b/src/routes/scheduling/conditions/new/+page.svelte
index 8055e5b013..eb3ab9adf7 100644
--- a/src/routes/scheduling/conditions/new/+page.svelte
+++ b/src/routes/scheduling/conditions/new/+page.svelte
@@ -1,20 +1,38 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
+  import { browser } from '$app/environment';
+  import { onMount } from 'svelte';
   import PageTitle from '../../../../components/app/PageTitle.svelte';
   import SchedulingConditionForm from '../../../../components/scheduling/conditions/SchedulingConditionForm.svelte';
+  import { SearchParameters } from '../../../../enums/searchParameters';
+  import { tags } from '../../../../stores/tags';
+  import { getSearchParameterNumber } from '../../../../utilities/generic';
   import type { PageData } from './$types';
 
   export let data: PageData;
+
+  let referenceModelId: number | null = null;
+
+  function onModelSelect(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    referenceModelId = modelId;
+  }
+
+  onMount(() => {
+    if (browser) {
+      const modelId = getSearchParameterNumber(SearchParameters.MODEL_ID) ?? null;
+      referenceModelId = modelId;
+    }
+  });
 </script>
 
 <PageTitle title="New Scheduling Condition" />
 
 <SchedulingConditionForm
-  initialConditionModelId={data.initialModelId}
-  initialSpecId={data.initialSpecId}
-  models={data.models}
-  plans={data.plans}
+  initialReferenceModelId={referenceModelId}
+  tags={$tags}
   mode="create"
   user={data.user}
+  on:selectReferenceModel={onModelSelect}
 />
diff --git a/src/routes/scheduling/conditions/new/+page.ts b/src/routes/scheduling/conditions/new/+page.ts
index 774ce34125..ee8329053d 100644
--- a/src/routes/scheduling/conditions/new/+page.ts
+++ b/src/routes/scheduling/conditions/new/+page.ts
@@ -1,23 +1,9 @@
-import { SearchParameters } from '../../../../enums/searchParameters';
-import effects from '../../../../utilities/effects';
-import { parseFloatOrNull } from '../../../../utilities/generic';
 import type { PageLoad } from './$types';
 
-export const load: PageLoad = async ({ parent, url }) => {
+export const load: PageLoad = async ({ parent }) => {
   const { user } = await parent();
 
-  const { models = [], plans = [] } = await effects.getPlansAndModelsForScheduling(user);
-
-  const modelId: string | null = url.searchParams.get(SearchParameters.MODEL_ID);
-  const specId: string | null = url.searchParams.get(SearchParameters.SPEC_ID);
-  const initialModelId: number | null = parseFloatOrNull(modelId);
-  const initialSpecId: number | null = parseFloatOrNull(specId);
-
   return {
-    initialModelId,
-    initialSpecId,
-    models,
-    plans,
     user,
   };
 };
diff --git a/src/routes/scheduling/goals/edit/[id]/+page.svelte b/src/routes/scheduling/goals/edit/[id]/+page.svelte
index 77e4639f6a..89e5de20d1 100644
--- a/src/routes/scheduling/goals/edit/[id]/+page.svelte
+++ b/src/routes/scheduling/goals/edit/[id]/+page.svelte
@@ -1,28 +1,104 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
+  import { browser } from '$app/environment';
+  import { page } from '$app/stores';
+  import { onMount } from 'svelte';
   import PageTitle from '../../../../../components/app/PageTitle.svelte';
   import SchedulingGoalForm from '../../../../../components/scheduling/goals/SchedulingGoalForm.svelte';
+  import { SearchParameters } from '../../../../../enums/searchParameters';
+  import { schedulingGoalMetadata, schedulingGoalMetadataId } from '../../../../../stores/scheduling';
+  import { tags } from '../../../../../stores/tags';
+  import type {
+    SchedulingGoalDefinition,
+    SchedulingGoalMetadataVersionDefinition,
+  } from '../../../../../types/scheduling';
+  import { getSearchParameterNumber, setQueryParam } from '../../../../../utilities/generic';
   import type { PageData } from './$types';
 
   export let data: PageData;
+
+  let goalRevision: number =
+    getSearchParameterNumber(SearchParameters.REVISION, $page.url.searchParams) ??
+    data.initialGoal.versions[data.initialGoal.versions.length - 1].revision;
+
+  let goalDefinition: Pick<SchedulingGoalDefinition, 'author' | 'definition' | 'revision' | 'tags'> =
+    data.initialGoal.versions.find(
+      ({ revision }) => revision === goalRevision,
+    ) as SchedulingGoalMetadataVersionDefinition;
+  let goalDefinitionCode = goalDefinition?.definition;
+  let goalDefinitionAuthor = goalDefinition?.author;
+  let goalDescription = data.initialGoal.description;
+  let goalId = data.initialGoal.id;
+  let goalName = data.initialGoal.name;
+  let goalPublic = data.initialGoal.public;
+  let goalDefinitionTags = goalDefinition.tags.map(({ tag }) => tag);
+  let goalMetadataTags = data.initialGoal.tags.map(({ tag }) => tag);
+  let goalOwner = data.initialGoal.owner;
+  let goalRevisions = data.initialGoal.versions.map(({ revision }) => revision);
+  let referenceModelId: number | null = null;
+
+  $: $schedulingGoalMetadataId = data.initialGoal.id;
+  $: if ($schedulingGoalMetadata != null && $schedulingGoalMetadata.id === $schedulingGoalMetadataId) {
+    goalDefinition = $schedulingGoalMetadata.versions.find(
+      ({ revision }) => revision === goalRevision,
+    ) as SchedulingGoalMetadataVersionDefinition;
+    if (goalDefinition != null) {
+      goalDefinitionAuthor = goalDefinition?.author;
+      goalDefinitionCode = goalDefinition?.definition;
+      goalDefinitionTags = goalDefinition?.tags.map(({ tag }) => tag);
+    }
+
+    goalDescription = $schedulingGoalMetadata.description;
+    goalId = $schedulingGoalMetadata.id;
+    goalName = $schedulingGoalMetadata.name;
+    goalPublic = $schedulingGoalMetadata.public;
+    goalMetadataTags = $schedulingGoalMetadata.tags.map(({ tag }) => tag);
+    goalOwner = $schedulingGoalMetadata.owner;
+    goalRevisions = $schedulingGoalMetadata.versions.map(({ revision }) => revision);
+  }
+
+  function onRevisionSelect(event: CustomEvent<number>) {
+    const { detail: revision } = event;
+    goalRevision = revision;
+    if (browser) {
+      setQueryParam(SearchParameters.REVISION, `${goalRevision}`);
+    }
+  }
+
+  function onModelSelect(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    if (browser) {
+      setQueryParam(SearchParameters.MODEL_ID, modelId != null ? `${modelId}` : null);
+    }
+  }
+
+  onMount(() => {
+    if (browser) {
+      const modelId = getSearchParameterNumber(SearchParameters.MODEL_ID) ?? null;
+      referenceModelId = modelId;
+    }
+  });
 </script>
 
 <PageTitle subTitle={data.initialGoal.name} title="Scheduling Goals" />
 
 <SchedulingGoalForm
-  initialGoalAuthor={data.initialGoal.author}
-  initialGoalCreatedDate={data.initialGoal.created_date}
-  initialGoalDefinition={data.initialGoal.definition}
-  initialGoalDescription={data.initialGoal.description}
-  initialGoalId={data.initialGoal.id}
-  initialGoalName={data.initialGoal.name}
-  initialGoalModelId={data.initialGoal.model_id}
-  initialGoalModifiedDate={data.initialGoal.modified_date}
-  initialGoalTags={data.initialGoal.tags.map(({ tag }) => tag)}
-  initialSpecId={data.initialSpecId}
-  models={data.models}
-  plans={data.plans}
+  initialGoalDefinitionAuthor={goalDefinitionAuthor}
+  initialGoalDefinitionCode={goalDefinitionCode}
+  initialGoalDescription={goalDescription}
+  initialGoalId={goalId}
+  initialGoalName={goalName}
+  initialGoalPublic={goalPublic}
+  initialGoalDefinitionTags={goalDefinitionTags}
+  initialGoalMetadataTags={goalMetadataTags}
+  initialGoalOwner={goalOwner}
+  initialGoalRevision={goalRevision}
+  initialReferenceModelId={referenceModelId}
+  {goalRevisions}
+  tags={$tags}
   mode="edit"
   user={data.user}
+  on:selectRevision={onRevisionSelect}
+  on:selectReferenceModel={onModelSelect}
 />
diff --git a/src/routes/scheduling/goals/edit/[id]/+page.ts b/src/routes/scheduling/goals/edit/[id]/+page.ts
index 5062f02194..9793c55e62 100644
--- a/src/routes/scheduling/goals/edit/[id]/+page.ts
+++ b/src/routes/scheduling/goals/edit/[id]/+page.ts
@@ -8,21 +8,19 @@ export const load: PageLoad = async ({ parent, params }) => {
   const { user } = await parent();
 
   const { id: goalIdParam } = params;
-  const { models = [], plans = [] } = await effects.getPlansAndModelsForScheduling(user);
 
-  if (goalIdParam !== null && goalIdParam !== undefined) {
+  if (goalIdParam !== null) {
     const goalId = parseFloatOrNull(goalIdParam);
-    const initialGoal = await effects.getSchedulingGoal(goalId, user);
-    const schedulingSpecGoals = await effects.getSchedulingSpecGoalsForGoal(goalId, user);
 
-    if (initialGoal !== null) {
-      return {
-        initialGoal,
-        initialSpecId: schedulingSpecGoals?.[0]?.specification_id,
-        models,
-        plans,
-        user,
-      };
+    if (goalId !== null) {
+      const initialGoal = await effects.getSchedulingGoal(goalId, user);
+
+      if (initialGoal !== null) {
+        return {
+          initialGoal,
+          user,
+        };
+      }
     }
   }
 
diff --git a/src/routes/scheduling/goals/new/+page.svelte b/src/routes/scheduling/goals/new/+page.svelte
index 317765bcfa..36fb7ce6c9 100644
--- a/src/routes/scheduling/goals/new/+page.svelte
+++ b/src/routes/scheduling/goals/new/+page.svelte
@@ -1,20 +1,38 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
+  import { browser } from '$app/environment';
+  import { onMount } from 'svelte';
   import PageTitle from '../../../../components/app/PageTitle.svelte';
   import SchedulingGoalForm from '../../../../components/scheduling/goals/SchedulingGoalForm.svelte';
+  import { SearchParameters } from '../../../../enums/searchParameters';
+  import { tags } from '../../../../stores/tags';
+  import { getSearchParameterNumber } from '../../../../utilities/generic';
   import type { PageData } from './$types';
 
   export let data: PageData;
+
+  let referenceModelId: number | null = null;
+
+  function onModelSelect(event: CustomEvent<number | null>) {
+    const { detail: modelId } = event;
+    referenceModelId = modelId;
+  }
+
+  onMount(() => {
+    if (browser) {
+      const modelId = getSearchParameterNumber(SearchParameters.MODEL_ID) ?? null;
+      referenceModelId = modelId;
+    }
+  });
 </script>
 
 <PageTitle title="New Scheduling Goal" />
 
 <SchedulingGoalForm
-  initialGoalModelId={data.initialModelId}
-  initialSpecId={data.initialSpecId}
+  initialReferenceModelId={referenceModelId}
+  tags={$tags}
   mode="create"
-  models={data.models}
-  plans={data.plans}
   user={data.user}
+  on:selectReferenceModel={onModelSelect}
 />
diff --git a/src/routes/scheduling/goals/new/+page.ts b/src/routes/scheduling/goals/new/+page.ts
index 774ce34125..ee8329053d 100644
--- a/src/routes/scheduling/goals/new/+page.ts
+++ b/src/routes/scheduling/goals/new/+page.ts
@@ -1,23 +1,9 @@
-import { SearchParameters } from '../../../../enums/searchParameters';
-import effects from '../../../../utilities/effects';
-import { parseFloatOrNull } from '../../../../utilities/generic';
 import type { PageLoad } from './$types';
 
-export const load: PageLoad = async ({ parent, url }) => {
+export const load: PageLoad = async ({ parent }) => {
   const { user } = await parent();
 
-  const { models = [], plans = [] } = await effects.getPlansAndModelsForScheduling(user);
-
-  const modelId: string | null = url.searchParams.get(SearchParameters.MODEL_ID);
-  const specId: string | null = url.searchParams.get(SearchParameters.SPEC_ID);
-  const initialModelId: number | null = parseFloatOrNull(modelId);
-  const initialSpecId: number | null = parseFloatOrNull(specId);
-
   return {
-    initialModelId,
-    initialSpecId,
-    models,
-    plans,
     user,
   };
 };
diff --git a/src/stores/constraints.ts b/src/stores/constraints.ts
index ad81b60b32..b5d067543f 100644
--- a/src/stores/constraints.ts
+++ b/src/stores/constraints.ts
@@ -24,8 +24,7 @@ export const checkConstraintsStatus: Writable<Status | null> = writable(null);
 
 export const rawConstraintResponses: Writable<ConstraintResponse[]> = writable([]);
 
-export const constraintsColumns: Writable<string> = writable('1fr 3px 2fr');
-export const constraintsFormColumns: Writable<string> = writable('1fr 3px 2fr');
+export const constraintsColumns: Writable<string> = writable('1fr 3px 1fr');
 
 /* Subscriptions. */
 
diff --git a/src/stores/scheduling.ts b/src/stores/scheduling.ts
index 51ea957261..6c59f995e3 100644
--- a/src/stores/scheduling.ts
+++ b/src/stores/scheduling.ts
@@ -1,25 +1,32 @@
+import { keyBy } from 'lodash-es';
 import { derived, writable, type Readable, type Writable } from 'svelte/store';
 import { Status } from '../enums/status';
-import { plan, planId, planRevision } from '../stores/plan';
+import { plan, planRevision } from '../stores/plan';
 import type {
-  SchedulingCondition,
+  SchedulingConditionDefinition,
+  SchedulingConditionMetadata,
+  SchedulingConditionMetadataResponse,
+  SchedulingConditionPlanSpecification,
   SchedulingGoalAnalysis,
-  SchedulingGoalSlim,
+  SchedulingGoalDefinition,
+  SchedulingGoalMetadata,
+  SchedulingGoalMetadataResponse,
+  SchedulingGoalPlanSpecification,
+  SchedulingPlanSpecification,
   SchedulingRequest,
-  SchedulingSpec,
-  SchedulingSpecCondition,
-  SchedulingSpecGoal,
 } from '../types/scheduling';
 import gql from '../utilities/gql';
+import { convertResponseToMetadata } from '../utilities/scheduling';
 import { simulationDatasetsPlan } from './simulation';
 import { gqlSubscribable } from './subscribable';
+import { tags } from './tags';
 
 /* Writeable. */
 
-export const schedulingColumns: Writable<string> = writable('2fr 3px 1fr');
-export const schedulingFormColumns: Writable<string> = writable('1fr 3px 2fr');
-export const schedulingConditionsFormColumns: Writable<string> = writable('1fr 3px 2fr');
-export const schedulingGoalsColumns: Writable<string> = writable('1fr 3px 2fr');
+export const schedulingConditionMetadataId: Writable<number> = writable(-1);
+export const schedulingGoalMetadataId: Writable<number> = writable(-1);
+
+export const schedulingColumns: Writable<string> = writable('1fr 3px 1fr');
 
 /* Derived. */
 
@@ -27,19 +34,6 @@ export const selectedSpecId = derived(plan, $plan => $plan?.scheduling_specifica
 
 /* Subscriptions. */
 
-export const schedulingSpec = gqlSubscribable<SchedulingSpec | null>(
-  gql.SUB_SCHEDULING_SPEC,
-  { planId },
-  null,
-  null,
-  (specs: SchedulingSpec[]) => {
-    if (specs && specs.length > 0) {
-      return specs[0];
-    }
-    return null;
-  },
-);
-
 export const schedulingRequests = gqlSubscribable<SchedulingRequest[]>(
   gql.SUB_SCHEDULING_REQUESTS,
   { specId: selectedSpecId },
@@ -47,101 +41,129 @@ export const schedulingRequests = gqlSubscribable<SchedulingRequest[]>(
   null,
 );
 
-export const schedulingConditionsAll = gqlSubscribable<SchedulingCondition[]>(
+export const schedulingConditionResponses = gqlSubscribable<SchedulingConditionMetadataResponse[]>(
   gql.SUB_SCHEDULING_CONDITIONS,
   {},
   [],
   null,
 );
 
+export const schedulingGoalResponses = gqlSubscribable<SchedulingGoalMetadataResponse[]>(
+  gql.SUB_SCHEDULING_GOALS,
+  {},
+  [],
+  null,
+);
+
+export const schedulingConditionResponse = gqlSubscribable<SchedulingConditionMetadataResponse | null>(
+  gql.SUB_SCHEDULING_CONDITION,
+  { id: schedulingConditionMetadataId },
+  null,
+  null,
+);
+
+export const schedulingGoalResponse = gqlSubscribable<SchedulingGoalMetadataResponse | null>(
+  gql.SUB_SCHEDULING_GOAL,
+  { id: schedulingGoalMetadataId },
+  null,
+  null,
+);
+
+export const schedulingPlanSpecification = gqlSubscribable<SchedulingPlanSpecification | null>(
+  gql.SUB_SCHEDULING_PLAN_SPECIFICATION,
+  { specificationId: selectedSpecId },
+  null,
+  null,
+);
+
+/* Derived. */
 export const schedulingConditions = derived(
-  [selectedSpecId, schedulingConditionsAll],
-  ([$selectedSpecId, $schedulingConditionsAll]) => {
-    return $schedulingConditionsAll.map(schedulingSpecCondition => {
-      return {
-        ...schedulingSpecCondition,
-        scheduling_specification_conditions: schedulingSpecCondition.scheduling_specification_conditions.filter(
-          condition => condition.specification_id === $selectedSpecId,
-        ),
-      };
-    });
+  [schedulingConditionResponses, tags],
+  ([$schedulingConditionResponses, $tags]) => {
+    return $schedulingConditionResponses.map(schedulingConditionResponse =>
+      convertResponseToMetadata<SchedulingConditionMetadata, SchedulingConditionDefinition>(
+        schedulingConditionResponse,
+        $tags,
+      ),
+    );
   },
 );
 
-export const schedulingGoalsAll = gqlSubscribable<SchedulingGoalSlim[]>(gql.SUB_SCHEDULING_GOALS, {}, [], null);
+export const schedulingGoals = derived([schedulingGoalResponses, tags], ([$schedulingGoalResponses, $tags]) => {
+  return $schedulingGoalResponses.map(schedulingGoalResponse =>
+    convertResponseToMetadata<SchedulingGoalMetadata, SchedulingGoalDefinition>(schedulingGoalResponse, $tags),
+  );
+});
 
-export const schedulingGoals = derived(
-  [selectedSpecId, schedulingGoalsAll],
-  ([$selectedSpecId, $schedulingGoalsAll]) => {
-    return $schedulingGoalsAll
-      .filter(goal => goal.scheduling_specification_goal?.specification_id === $selectedSpecId)
-      .map(goal => {
-        return {
-          ...goal,
-          analyses: goal.analyses.filter(analysis => analysis.request.specification_id === $selectedSpecId),
-        };
-      });
+export const schedulingConditionMetadata = derived(
+  [schedulingConditionResponse, tags],
+  ([$schedulingConditionResponse, $tags]) => {
+    if ($schedulingConditionResponse) {
+      return convertResponseToMetadata<SchedulingConditionMetadata, SchedulingConditionDefinition>(
+        $schedulingConditionResponse,
+        $tags,
+      );
+    }
+    return null;
   },
 );
 
-export const schedulingSpecConditionsAll = gqlSubscribable<SchedulingSpecCondition[]>(
-  gql.SUB_SCHEDULING_SPEC_CONDITIONS,
-  { specification_id: selectedSpecId },
-  [],
-  null,
+export const schedulingGoalMetadata = derived([schedulingGoalResponse, tags], ([$schedulingGoalResponse, $tags]) => {
+  if ($schedulingGoalResponse) {
+    return convertResponseToMetadata<SchedulingGoalMetadata, SchedulingGoalDefinition>($schedulingGoalResponse, $tags);
+  }
+  return null;
+});
+
+export const schedulingConditionsMap: Readable<Record<string, SchedulingConditionMetadata>> = derived(
+  [schedulingConditions],
+  ([$schedulingConditions]) => keyBy($schedulingConditions, 'id'),
 );
 
-export const schedulingSpecConditions = derived(
-  [selectedSpecId, schedulingSpecConditionsAll],
-  ([$selectedSpecId, $schedulingSpecConditionsAll]) => {
-    return $schedulingSpecConditionsAll
-      .filter(schedulingSpecCondition => schedulingSpecCondition.specification_id === $selectedSpecId)
-      .map(schedulingSpecCondition => {
-        return {
-          ...schedulingSpecCondition,
-          condition: {
-            ...schedulingSpecCondition.condition,
-            scheduling_specification_conditions:
-              schedulingSpecCondition.condition.scheduling_specification_conditions.filter(
-                condition => condition.specification_id === $selectedSpecId,
-              ),
-          },
-        };
-      });
-  },
+export const schedulingGoalsMap: Readable<Record<string, SchedulingGoalMetadata>> = derived(
+  [schedulingGoals],
+  ([$schedulingGoals]) => keyBy($schedulingGoals, 'id'),
 );
 
-export const schedulingSpecGoalsAll = gqlSubscribable<SchedulingSpecGoal[]>(
-  gql.SUB_SCHEDULING_SPEC_GOALS,
-  { specification_id: selectedSpecId },
-  [],
-  null,
+export const schedulingConditionSpecifications = derived(
+  [schedulingPlanSpecification],
+  ([$schedulingPlanSpecification]) => $schedulingPlanSpecification?.conditions ?? [],
 );
 
-export const schedulingSpecGoals = derived(
-  [selectedSpecId, schedulingSpecGoalsAll],
-  ([$selectedSpecId, $schedulingSpecGoalsAll]) => {
-    return $schedulingSpecGoalsAll
-      .filter(schedulingSpecGoal => schedulingSpecGoal.specification_id === $selectedSpecId)
-      .map(specGoal => {
-        return {
-          ...specGoal,
-          goal: {
-            ...specGoal.goal,
-            analyses: specGoal.goal.analyses.filter(analysis => analysis.request.specification_id === $selectedSpecId),
-          },
-        };
-      });
-  },
+export const schedulingGoalSpecifications = derived(
+  [schedulingPlanSpecification],
+  ([$schedulingPlanSpecification]) => $schedulingPlanSpecification?.goals ?? [],
+);
+
+export const allowedSchedulingConditionSpecs: Readable<SchedulingConditionPlanSpecification[]> = derived(
+  [schedulingConditionSpecifications],
+  ([$schedulingConditionSpecifications]) =>
+    $schedulingConditionSpecifications.filter(
+      ({ condition_metadata: conditionMetadata }) => conditionMetadata !== null,
+    ),
+);
+
+export const allowedSchedulingGoalSpecs: Readable<SchedulingGoalPlanSpecification[]> = derived(
+  [schedulingGoalSpecifications],
+  ([$schedulingGoalSpecifications]) =>
+    $schedulingGoalSpecifications.filter(({ goal_metadata: goalMetadata }) => goalMetadata !== null),
 );
 
 export const latestSchedulingGoalAnalyses = derived(
-  [selectedSpecId, schedulingSpecGoals],
-  ([$selectedSpecId, $schedulingSpecGoals]) => {
+  [selectedSpecId, schedulingGoalSpecifications],
+  ([$selectedSpecId, $schedulingGoalSpecifications]) => {
     const analysisIdToSpecGoalMap: Record<number, SchedulingGoalAnalysis[]> = {};
     let latestAnalysisId = -1;
-    $schedulingSpecGoals.forEach(schedulingSpecGoal => {
-      schedulingSpecGoal.goal.analyses.forEach(analysis => {
+
+    $schedulingGoalSpecifications.forEach(schedulingSpecGoal => {
+      let analyses: SchedulingGoalAnalysis[] = [];
+      if (schedulingSpecGoal.goal_definition != null) {
+        analyses = schedulingSpecGoal.goal_definition.analyses ?? [];
+      } else {
+        analyses = schedulingSpecGoal.goal_metadata?.versions[0].analyses ?? [];
+      }
+
+      analyses.forEach(analysis => {
         if (analysis.request.specification_id !== $selectedSpecId) {
           return;
         }
@@ -154,6 +176,7 @@ export const latestSchedulingGoalAnalyses = derived(
         }
       });
     });
+
     return analysisIdToSpecGoalMap[latestAnalysisId] || [];
   },
 );
@@ -176,7 +199,7 @@ export const schedulingAnalysisStatus = derived(
   [
     latestSchedulingRequest,
     latestSchedulingGoalAnalyses,
-    schedulingSpec,
+    schedulingPlanSpecification,
     planRevision,
     schedulingGoalCount,
     schedulingGoals,
@@ -186,7 +209,7 @@ export const schedulingAnalysisStatus = derived(
   ([
     $latestSchedulingRequest,
     $latestSchedulingGoalAnalyses,
-    $schedulingSpec,
+    $schedulingPlanSpecification,
     $planRevision,
     $schedulingGoalCount,
     $schedulingGoals,
@@ -218,12 +241,14 @@ export const schedulingAnalysisStatus = derived(
       if (matchingSimDataset) {
         schedulingPlanRevOutdated = !!matchingSimDataset && matchingSimDataset.plan_revision !== $planRevision;
       } else {
-        schedulingPlanRevOutdated = !!$schedulingSpec && $schedulingSpec?.plan_revision !== $planRevision;
+        schedulingPlanRevOutdated =
+          !!$schedulingPlanSpecification && $schedulingPlanSpecification?.plan_revision !== $planRevision;
       }
 
       if (
         schedulingPlanRevOutdated ||
-        ($schedulingSpec && $schedulingSpec.revision !== $latestSchedulingRequest.specification_revision)
+        ($schedulingPlanSpecification &&
+          $schedulingPlanSpecification.revision !== $latestSchedulingRequest.specification_revision)
       ) {
         return Status.Modified;
       } else if ($latestSchedulingRequest.status === 'failed') {
@@ -241,6 +266,9 @@ export const schedulingAnalysisStatus = derived(
   },
 );
 
-export const enableScheduling: Readable<boolean> = derived([schedulingSpecGoals], ([$schedulingSpecGoals]) => {
-  return $schedulingSpecGoals.filter(schedulingSpecGoal => schedulingSpecGoal.enabled).length > 0;
-});
+export const enableScheduling: Readable<boolean> = derived(
+  [schedulingGoalSpecifications],
+  ([$schedulingGoalSpecifications]) => {
+    return $schedulingGoalSpecifications.filter(schedulingSpecGoal => schedulingSpecGoal.enabled).length > 0;
+  },
+);
diff --git a/src/types/constraint.ts b/src/types/constraint.ts
index 3e01d27e8a..cacd04924d 100644
--- a/src/types/constraint.ts
+++ b/src/types/constraint.ts
@@ -1,19 +1,10 @@
-import type { PartialWith, UserId } from './app';
-import type { Model } from './model';
-import type { Plan } from './plan';
-import type { ConstraintTagsInsertInput, Tag } from './tags';
+import type { PartialWith } from './app';
+import type { BaseDefinition, BaseMetadata } from './metadata';
+import type { ConstraintTagsInsertInput } from './tags';
 import type { TimeRange } from './timeline';
 
-export type ConstraintDefinition = {
-  author: UserId;
+export type ConstraintDefinition = BaseDefinition & {
   constraint_id: number;
-  created_at: string;
-  definition: string;
-  metadata: ConstraintMetadata;
-  // models_using: Model[];
-  // plans_using: Plan[];
-  revision: number;
-  tags: { tag: Tag }[];
 };
 
 export type ConstraintMetadataVersionDefinition = Pick<
@@ -21,20 +12,7 @@ export type ConstraintMetadataVersionDefinition = Pick<
   'author' | 'definition' | 'revision' | 'tags'
 >;
 
-export type ConstraintMetadata = {
-  created_at: string;
-  description?: string;
-  id: number;
-  models_using: Pick<Model, 'id'>[];
-  name: string;
-  owner: UserId;
-  plans_using: Pick<Plan, 'id'>[];
-  public: boolean;
-  tags: { tag: Tag }[];
-  updated_at: string;
-  updated_by: UserId;
-  versions: ConstraintMetadataVersionDefinition[];
-};
+export type ConstraintMetadata = BaseMetadata<ConstraintDefinition>;
 
 export type ConstraintMetadataSlim = Omit<ConstraintMetadata, 'models_using' | 'plans_using' | 'versions'>;
 
@@ -49,7 +27,9 @@ export type ConstraintModelSpec = {
 
 export type ConstraintPlanSpec = {
   constraint_id: number;
-  constraint_metadata: Pick<ConstraintMetadata, 'name' | 'owner' | 'public' | 'versions'> | null;
+  constraint_metadata:
+    | (Pick<ConstraintMetadata, 'name' | 'owner' | 'public'> & { versions: Pick<ConstraintDefinition, 'revision'>[] })
+    | null;
   constraint_revision: number | null;
   enabled: boolean;
   plan_id: number;
diff --git a/src/types/metadata.ts b/src/types/metadata.ts
new file mode 100644
index 0000000000..962a603a23
--- /dev/null
+++ b/src/types/metadata.ts
@@ -0,0 +1,34 @@
+import type { UserId } from './app';
+import type { Model } from './model';
+import type { Plan } from './plan';
+import type { Tag } from './tags';
+
+export type BaseDefinition = {
+  author: UserId;
+  created_at: string;
+  definition: string;
+  metadata: BaseMetadata<BaseDefinition>;
+  models_using: Pick<Model, 'id'>[];
+  plans_using: Pick<Plan, 'id'>[];
+  revision: number;
+  tags: { tag: Tag }[];
+};
+
+export type BaseMetadataVersionDefinition = Pick<BaseDefinition, 'author' | 'definition' | 'revision' | 'tags'>;
+
+export type BaseMetadata<D> = {
+  created_at: string;
+  description?: string;
+  id: number;
+  models_using: Pick<Model, 'id'>[];
+  name: string;
+  owner: UserId;
+  plans_using: Pick<Plan, 'id'>[];
+  public: boolean;
+  tags: { tag: Tag }[];
+  updated_at: string;
+  updated_by: UserId;
+  versions: D[];
+};
+
+export type BaseMetadataSlim<D> = Omit<BaseMetadata<D>, 'models_using' | 'plans_using' | 'versions'>;
diff --git a/src/types/plan.ts b/src/types/plan.ts
index 235c14df3d..1ede5989fd 100644
--- a/src/types/plan.ts
+++ b/src/types/plan.ts
@@ -2,7 +2,7 @@ import type { ActivityDirective } from './activity';
 import type { UserId } from './app';
 import type { ConstraintPlanSpec } from './constraint';
 import type { Model } from './model';
-import type { SchedulingSpec } from './scheduling';
+import type { SchedulingPlanSpecification } from './scheduling';
 import type { Tag } from './tags';
 
 export type Plan = PlanSchema & { end_time_doy: string; start_time_doy: string };
@@ -84,7 +84,7 @@ export type PlanSchema = {
   owner: UserId;
   parent_plan: Pick<PlanSchema, 'id' | 'name' | 'owner' | 'collaborators' | 'is_locked'> | null;
   revision: number;
-  scheduling_specification: Pick<SchedulingSpec, 'id'> | null;
+  scheduling_specification: Pick<SchedulingPlanSpecification, 'id'> | null;
   simulations: [{ simulation_datasets: [{ id: number; plan_revision: number }] }];
   start_time: string;
   tags: { tag: Tag }[];
diff --git a/src/types/scheduling.ts b/src/types/scheduling.ts
index 9f116f7801..922da4ef60 100644
--- a/src/types/scheduling.ts
+++ b/src/types/scheduling.ts
@@ -1,81 +1,125 @@
+import type { PartialWith } from './app';
 import type { SchedulingError } from './errors';
+import type { BaseDefinition, BaseMetadata } from './metadata';
 import type { ArgumentsMap } from './parameter';
-import type { Tag } from './tags';
-
-export type SchedulingGoal = {
-  analyses: SchedulingGoalAnalysis[];
-  author: string | null;
-  created_date: string;
-  definition: string;
-  description?: string;
-  id: number;
-  last_modified_by: string | null;
-  model_id: number;
-  modified_date: string;
-  name: string;
-  revision: number;
-  scheduling_specification_goal: {
-    specification_id: number;
-  } | null;
-  tags: { tag: Tag }[];
-};
+import type { SchedulingTagsInsertInput } from './tags';
 
-export type SchedulingGoalSlim = Omit<SchedulingGoal, 'tags'> & { tags: { tag_id: number }[] };
+type SchedulingDefinitionResponse<D> = Omit<D, 'tags'> & {
+  tags: { tag_id: number }[];
+};
 
-export type SchedulingCondition = {
-  author: string | null;
-  created_date: string;
-  definition: string;
-  description?: string;
-  id: number;
-  last_modified_by: string | null;
-  model_id: number;
-  modified_date: string;
-  name: string;
-  revision: number;
-  scheduling_specification_conditions: {
-    specification_id: number;
+export type SchedulingConditionDefinition = BaseDefinition & {
+  condition_id: number;
+};
+export type SchedulingMetadataResponse<M, D> = Omit<M, 'plans_using' | 'tags' | 'versions'> & {
+  plans_using?: {
+    specification: {
+      plan_id: number;
+    };
   }[];
+  tags: { tag_id: number }[];
+  versions: SchedulingDefinitionResponse<D>[];
 };
 
+export type SchedulingConditionMetadata = BaseMetadata<SchedulingConditionDefinition>;
+export type SchedulingConditionMetadataResponse = SchedulingMetadataResponse<
+  SchedulingConditionMetadata,
+  SchedulingConditionDefinition
+>;
+
+export type SchedulingConditionMetadataVersionDefinition = Pick<
+  SchedulingConditionDefinition,
+  'author' | 'definition' | 'revision' | 'tags'
+>;
+
+export type SchedulingGoalDefinition = BaseDefinition & {
+  analyses?: SchedulingGoalAnalysis[];
+  goal_id: number;
+};
+export type SchedulingGoalMetadata = BaseMetadata<SchedulingGoalDefinition> & {
+  analyses?: SchedulingGoalAnalysis[];
+};
+
+export type SchedulingGoalMetadataResponse = SchedulingMetadataResponse<
+  SchedulingGoalMetadata,
+  SchedulingGoalDefinition
+>;
+
+export type SchedulingConditionMetadataSlim = Omit<
+  SchedulingConditionMetadata,
+  'models_using' | 'plans_using' | 'versions'
+>;
+export type SchedulingGoalMetadataSlim = Omit<SchedulingGoalMetadata, 'models_using' | 'plans_using' | 'versions'>;
+
+export type SchedulingGoalMetadataVersionDefinition = Pick<
+  SchedulingGoalDefinition,
+  'author' | 'definition' | 'revision' | 'tags'
+>;
+
+export type SchedulingConditionDefinitionInsertInput = Pick<
+  SchedulingConditionDefinition,
+  'condition_id' | 'definition'
+> & {
+  tags: {
+    data: SchedulingTagsInsertInput[];
+  };
+};
+
+export type SchedulingGoalDefinitionInsertInput = Pick<SchedulingGoalDefinition, 'goal_id' | 'definition'> & {
+  tags: {
+    data: SchedulingTagsInsertInput[];
+  };
+};
+
+export type SchedulingConditionInsertInput = Omit<
+  SchedulingConditionMetadataSlim,
+  'id' | 'created_at' | 'updated_at' | 'owner' | 'updated_by' | 'tags'
+> & {
+  tags: {
+    data: SchedulingTagsInsertInput[];
+  };
+  versions: {
+    data: Omit<SchedulingConditionDefinitionInsertInput, 'condition_id'>[];
+  };
+};
+
+export type SchedulingGoalInsertInput = Omit<
+  SchedulingGoalMetadataSlim,
+  'id' | 'created_at' | 'updated_at' | 'owner' | 'updated_by' | 'tags'
+> & {
+  tags: {
+    data: SchedulingTagsInsertInput[];
+  };
+  versions: {
+    data: Omit<SchedulingGoalDefinitionInsertInput, 'goal_id'>[];
+  };
+};
+
+export type SchedulingConditionPlanSpecInsertInput = Omit<SchedulingConditionPlanSpecification, 'condition_metadata'>;
+export type SchedulingGoalPlanSpecInsertInput = Omit<SchedulingGoalPlanSpecification, 'goal_metadata'>;
+
+export type SchedulingConditionMetadataSetInput = PartialWith<SchedulingConditionMetadata, 'owner'>;
+export type SchedulingGoalMetadataSetInput = PartialWith<SchedulingGoalMetadata, 'owner'>;
+
 export type SchedulingGoalAnalysis = {
   analysis_id: number;
+  goal_definition: SchedulingGoalDefinition;
+  goal_id: number;
+  goal_revision: number;
   request: { specification_id: number };
   satisfied: boolean;
   satisfying_activities: { activity_id: number }[];
 };
 
-export type SchedulingConditionInsertInput = Omit<
-  SchedulingCondition,
-  | 'author'
-  | 'created_date'
-  | 'id'
-  | 'last_modified_by'
-  | 'modified_date'
-  | 'revision'
-  | 'scheduling_specification_conditions'
->;
-
-export type SchedulingGoalInsertInput = Omit<
-  SchedulingGoal,
-  | 'analyses'
-  | 'author'
-  | 'created_date'
-  | 'id'
-  | 'last_modified_by'
-  | 'modified_date'
-  | 'revision'
-  | 'scheduling_specification_goal'
-  | 'tags'
->;
-
 export type SchedulingResponse = {
   analysisId: number | null;
   reason: SchedulingError;
 };
 
-export type SchedulingSpec = {
+export type SchedulingPlanSpecification = {
   analysis_only: boolean;
+  conditions?: SchedulingConditionPlanSpecification[];
+  goals?: SchedulingGoalPlanSpecification[];
   horizon_end: string;
   horizon_start: string;
   id: number;
@@ -85,32 +129,33 @@ export type SchedulingSpec = {
   simulation_arguments: ArgumentsMap;
 };
 
-export type SchedulingSpecInsertInput = Omit<SchedulingSpec, 'id' | 'revision'>;
+export type SchedulingPlanSpecificationInsertInput = Omit<SchedulingPlanSpecification, 'id' | 'revision'>;
 
-export type SchedulingSpecCondition = {
-  condition: SchedulingCondition;
-  enabled: boolean;
-  specification: SchedulingSpec;
-  specification_id: number;
-};
-
-export type SchedulingSpecGoal = {
-  enabled: boolean;
-  goal: SchedulingGoalSlim;
-  priority: number;
-  simulate_after: boolean;
-  specification_id: number;
-};
-
-export type SchedulingSpecConditionInsertInput = {
+export type SchedulingConditionPlanSpecification = {
+  // condition_definition: SchedulingConditionDefinition;
   condition_id: number;
+  condition_metadata:
+    | (Pick<SchedulingConditionMetadata, 'name' | 'owner' | 'public'> & {
+        versions: Pick<SchedulingConditionDefinition, 'revision'>;
+      })
+    | null;
+  condition_revision: number | null;
   enabled: boolean;
   specification_id: number;
 };
 
-export type SchedulingSpecGoalInsertInput = {
+export type SchedulingGoalPlanSpecification = {
   enabled: boolean;
+  goal_definition?: Pick<SchedulingGoalDefinition, 'analyses'> | null;
   goal_id: number;
+  goal_metadata:
+    | (Pick<SchedulingGoalMetadata, 'name' | 'owner' | 'public'> & {
+        versions: Pick<SchedulingGoalDefinition, 'revision' | 'analyses'>[];
+      })
+    | null;
+  goal_revision: number | null;
+  priority: number;
+  simulate_after: boolean;
   specification_id: number;
 };
 
diff --git a/src/types/tags.ts b/src/types/tags.ts
index 1f6284a452..6aab267cae 100644
--- a/src/types/tags.ts
+++ b/src/types/tags.ts
@@ -21,11 +21,37 @@ export type ConstraintDefinitionTagsInsertInput = {
   tag_id: number;
 };
 
+export type SchedulingConditionMetadataTagsInsertInput = {
+  condition_id: number;
+  tag_id: number;
+};
+
+export type SchedulingConditionDefinitionTagsInsertInput = {
+  condition_id: number;
+  condition_revision: number;
+  tag_id: number;
+};
+
+export type SchedulingGoalMetadataTagsInsertInput = {
+  goal_id: number;
+  tag_id: number;
+};
+
+export type SchedulingGoalDefinitionTagsInsertInput = {
+  goal_id: number;
+  goal_revision: number;
+  tag_id: number;
+};
+
 export type ExpansionRuleTagsInsertInput = {
   rule_id: number;
   tag_id: number;
 };
 
+export type SchedulingTagsInsertInput = {
+  tag_id: number;
+};
+
 export type SchedulingGoalTagsInsertInput = {
   goal_id: number;
   tag_id: number;
diff --git a/src/utilities/effects.ts b/src/utilities/effects.ts
index 390f532850..3868f6d449 100644
--- a/src/utilities/effects.ts
+++ b/src/utilities/effects.ts
@@ -89,25 +89,31 @@ import type {
   PlanMergeNonConflictingActivity,
   PlanMergeRequestSchema,
   PlanMergeResolution,
-  PlanSchedulingSpec,
   PlanSchema,
   PlanSlim,
 } from '../types/plan';
 import type { PlanSnapshot } from '../types/plan-snapshot';
 import type {
-  SchedulingCondition,
+  SchedulingConditionDefinition,
+  SchedulingConditionDefinitionInsertInput,
   SchedulingConditionInsertInput,
-  SchedulingGoal,
+  SchedulingConditionMetadata,
+  SchedulingConditionMetadataResponse,
+  SchedulingConditionMetadataSetInput,
+  SchedulingConditionPlanSpecInsertInput,
+  SchedulingConditionPlanSpecification,
+  SchedulingGoalDefinition,
+  SchedulingGoalDefinitionInsertInput,
   SchedulingGoalInsertInput,
-  SchedulingGoalSlim,
+  SchedulingGoalMetadata,
+  SchedulingGoalMetadataResponse,
+  SchedulingGoalMetadataSetInput,
+  SchedulingGoalPlanSpecInsertInput,
+  SchedulingGoalPlanSpecification,
+  SchedulingPlanSpecification,
+  SchedulingPlanSpecificationInsertInput,
   SchedulingRequest,
   SchedulingResponse,
-  SchedulingSpec,
-  SchedulingSpecCondition,
-  SchedulingSpecConditionInsertInput,
-  SchedulingSpecGoal,
-  SchedulingSpecGoalInsertInput,
-  SchedulingSpecInsertInput,
 } from '../types/scheduling';
 import type { ValueSchema } from '../types/schema';
 import type {
@@ -138,7 +144,11 @@ import type {
   ExpansionRuleTagsInsertInput,
   PlanSnapshotTagsInsertInput,
   PlanTagsInsertInput,
-  SchedulingGoalTagsInsertInput,
+  SchedulingConditionDefinitionTagsInsertInput,
+  SchedulingConditionMetadataTagsInsertInput,
+  SchedulingGoalDefinitionTagsInsertInput,
+  SchedulingGoalMetadataTagsInsertInput,
+  SchedulingTagsInsertInput,
   Tag,
   TagsInsertInput,
   TagsSetInput,
@@ -156,6 +166,8 @@ import {
   showDeleteActivitiesModal,
   showEditViewModal,
   showManagePlanConstraintsModal,
+  showManagePlanSchedulingConditionsModal,
+  showManagePlanSchedulingGoalsModal,
   showPlanBranchRequestModal,
   showRestorePlanSnapshotModal,
   showUploadViewModal,
@@ -163,6 +175,7 @@ import {
 import { queryPermissions } from './permissions';
 import { reqExtension, reqGateway, reqHasura } from './requests';
 import { sampleProfiles } from './resources';
+import { convertResponseToMetadata } from './scheduling';
 import { pluralize } from './text';
 import { getDoyTime, getDoyTimeFromInterval, getIntervalFromDoyRange } from './time';
 import { createRow, duplicateRow } from './timeline';
@@ -848,7 +861,7 @@ const effects = {
         }
 
         if (
-          !(await effects.createSchedulingSpec(
+          !(await effects.createSchedulingPlanSpecification(
             {
               analysis_only: false,
               horizon_end: end_time_doy,
@@ -912,7 +925,7 @@ const effects = {
         const { duplicate_plan } = data;
         if (duplicate_plan != null) {
           const { new_plan_id } = duplicate_plan;
-          await effects.createSchedulingSpec(
+          await effects.createSchedulingPlanSpecification(
             {
               analysis_only: false,
               horizon_end: plan.end_time_doy,
@@ -1108,158 +1121,247 @@ const effects = {
   },
 
   async createSchedulingCondition(
-    definition: string,
     name: string,
-    modelId: number,
-    plan: Pick<PlanSchedulingSpec, 'id' | 'name' | 'owner' | 'model_id' | 'collaborators'>,
+    isPublic: boolean,
+    metadataTags: SchedulingTagsInsertInput[],
+    definition: string,
+    definitionTags: SchedulingTagsInsertInput[],
     user: User | null,
     description?: string,
-  ): Promise<SchedulingCondition | null> {
+  ): Promise<number | null> {
     try {
-      if (!queryPermissions.CREATE_SCHEDULING_CONDITION(user, plan)) {
+      if (!queryPermissions.CREATE_SCHEDULING_CONDITION(user)) {
         throwPermissionError('create a scheduling condition');
       }
 
       const conditionInsertInput: SchedulingConditionInsertInput = {
-        definition,
-        model_id: modelId,
+        ...(description ? { description } : {}),
         name,
-        ...(description && { description }),
+        public: isPublic,
+        tags: {
+          data: metadataTags,
+        },
+        versions: {
+          data: [
+            {
+              definition,
+              tags: {
+                data: definitionTags,
+              },
+            },
+          ],
+        },
       };
-      const data = await reqHasura<SchedulingCondition>(
+      const data = await reqHasura<SchedulingConditionMetadata>(
         gql.CREATE_SCHEDULING_CONDITION,
         { condition: conditionInsertInput },
         user,
       );
-      const { createSchedulingCondition: newCondition } = data;
+      const { createSchedulingCondition } = data;
+      if (createSchedulingCondition != null) {
+        const { id } = createSchedulingCondition;
 
-      if (newCondition != null) {
         showSuccessToast('Scheduling Condition Created Successfully');
-        return newCondition;
+        return id;
       } else {
         throw Error(`Unable to create scheduling condition "${name}"`);
       }
     } catch (e) {
-      catchError('Scheduling Condition Create Failed', e as Error);
-      showFailureToast('Scheduling Condition Create Failed');
+      catchError('Scheduling Condition Creation Failed', e as Error);
+      showFailureToast('Scheduling Condition Creation Failed');
       return null;
     }
   },
 
-  async createSchedulingGoal(
+  async createSchedulingConditionDefinition(
+    conditionId: number,
     definition: string,
-    name: string,
-    modelId: number,
-    plan: Pick<PlanSchedulingSpec, 'id' | 'name' | 'owner' | 'model_id' | 'collaborators'>,
+    definitionTags: SchedulingTagsInsertInput[],
     user: User | null,
-    description?: string,
-  ): Promise<SchedulingGoal | null> {
+  ): Promise<Pick<SchedulingConditionDefinition, 'condition_id' | 'definition' | 'revision'> | null> {
     try {
-      if (!queryPermissions.CREATE_SCHEDULING_GOAL(user, plan)) {
-        throwPermissionError('create a scheduling goal');
+      if (!queryPermissions.CREATE_SCHEDULING_CONDITION_DEFINITION(user)) {
+        throwPermissionError('create a scheduling condition definition');
       }
 
-      const goalInsertInput: SchedulingGoalInsertInput = {
+      const conditionDefinitionInsertInput: SchedulingConditionDefinitionInsertInput = {
+        condition_id: conditionId,
         definition,
-        model_id: modelId,
-        name,
-        ...(description && { description }),
+        tags: {
+          data: definitionTags,
+        },
       };
-      const data = await reqHasura<SchedulingGoal>(gql.CREATE_SCHEDULING_GOAL, { goal: goalInsertInput }, user);
-      const { createSchedulingGoal: newGoal } = data;
-
-      if (newGoal != null) {
-        showSuccessToast('Scheduling Goal Created Successfully');
-        return newGoal;
+      const data = await reqHasura<SchedulingConditionDefinition>(
+        gql.CREATE_SCHEDULING_CONDITION_DEFINITION,
+        { conditionDefinition: conditionDefinitionInsertInput },
+        user,
+      );
+      const { conditionDefinition } = data;
+      if (conditionDefinition != null) {
+        showSuccessToast('New Scheduling Condition Revision Created Successfully');
+        return conditionDefinition;
       } else {
-        throw Error(`Unable to create scheduling goal "${name}"`);
+        throw Error(`Unable to create condition definition for scheduling condition "${conditionId}"`);
       }
     } catch (e) {
-      catchError('Scheduling Goal Create Failed', e as Error);
-      showFailureToast('Scheduling Goal Create Failed');
+      catchError('Scheduling Condition Creation Failed', e as Error);
+      showFailureToast('Scheduling Condition Creation Failed');
       return null;
     }
   },
 
-  async createSchedulingGoalTags(tags: SchedulingGoalTagsInsertInput[], user: User | null): Promise<number | null> {
+  // async createSchedulingConditionPlanSpecification(
+  //   spec_condition: SchedulingSpecConditionInsertInput,
+  //   user: User | null,
+  // ): Promise<void> {
+  //   try {
+  //     if (!queryPermissions.CREATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION(user)) {
+  //       throwPermissionError('create a scheduling spec condition');
+  //     }
+
+  //     const data = await reqHasura<SchedulingConditionPlanSpecification>(
+  //       gql.CREATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION,
+  //       { spec_condition },
+  //       user,
+  //     );
+  //     if (data.createSchedulingSpecCondition == null) {
+  //       throw Error('Unable to create a scheduling spec condition');
+  //     }
+  //   } catch (e) {
+  //     catchError(e as Error);
+  //   }
+  // },
+
+  async createSchedulingGoal(
+    name: string,
+    isPublic: boolean,
+    metadataTags: SchedulingTagsInsertInput[],
+    definition: string,
+    definitionTags: SchedulingTagsInsertInput[],
+    user: User | null,
+    description?: string,
+  ): Promise<number | null> {
     try {
-      if (!queryPermissions.CREATE_SCHEDULING_GOAL_TAGS(user)) {
-        throwPermissionError('create scheduling goal tags');
+      if (!queryPermissions.CREATE_SCHEDULING_CONDITION(user)) {
+        throwPermissionError('create a scheduling condition');
       }
 
-      const data = await reqHasura<{ affected_rows: number }>(gql.CREATE_SCHEDULING_GOAL_TAGS, { tags }, user);
-      const { insert_scheduling_goal_tags } = data;
-      if (insert_scheduling_goal_tags != null) {
-        const { affected_rows } = insert_scheduling_goal_tags;
+      const goalInsertInput: SchedulingGoalInsertInput = {
+        ...(description ? { description } : {}),
+        name,
+        public: isPublic,
+        tags: {
+          data: metadataTags,
+        },
+        versions: {
+          data: [
+            {
+              definition,
+              tags: {
+                data: definitionTags,
+              },
+            },
+          ],
+        },
+      };
+
+      const data = await reqHasura<SchedulingGoalMetadata>(gql.CREATE_SCHEDULING_GOAL, { goal: goalInsertInput }, user);
+      const { createSchedulingGoal } = data;
+      if (createSchedulingGoal != null) {
+        const { id } = createSchedulingGoal;
 
-        if (affected_rows !== tags.length) {
-          throw Error('Some scheduling goal tags were not successfully created');
-        }
-        return affected_rows;
+        showSuccessToast('Scheduling Goal Created Successfully');
+        return id;
       } else {
-        throw Error('Unable to create scheduling goal tags');
+        throw Error(`Unable to create scheduling goal "${name}"`);
       }
     } catch (e) {
-      catchError('Create Scheduling Goal Tags Failed', e as Error);
-      showFailureToast('Create Scheduling Goal Tags Failed');
+      catchError('Scheduling Goal Creation Failed', e as Error);
+      showFailureToast('Scheduling Goal Creation Failed');
       return null;
     }
   },
 
-  async createSchedulingSpec(
-    spec: SchedulingSpecInsertInput,
+  async createSchedulingGoalDefinition(
+    goalId: number,
+    definition: string,
+    definitionTags: SchedulingTagsInsertInput[],
     user: User | null,
-  ): Promise<Pick<SchedulingSpec, 'id'> | null> {
+  ): Promise<Pick<SchedulingGoalDefinition, 'goal_id' | 'definition' | 'revision'> | null> {
     try {
-      if (!queryPermissions.CREATE_SCHEDULING_SPEC(user)) {
-        throwPermissionError('create a scheduling spec');
+      if (!queryPermissions.CREATE_SCHEDULING_GOAL_DEFINITION(user)) {
+        throwPermissionError('create a scheduling goal definition');
       }
 
-      const data = await reqHasura<Pick<SchedulingSpec, 'id'>>(gql.CREATE_SCHEDULING_SPEC, { spec }, user);
-      const { createSchedulingSpec: newSchedulingSpec } = data;
-      return newSchedulingSpec;
+      const goalDefinitionInsertInput: SchedulingGoalDefinitionInsertInput = {
+        definition,
+        goal_id: goalId,
+        tags: {
+          data: definitionTags,
+        },
+      };
+      const data = await reqHasura<SchedulingGoalDefinition>(
+        gql.CREATE_SCHEDULING_GOAL_DEFINITION,
+        { goalDefinition: goalDefinitionInsertInput },
+        user,
+      );
+      const { goalDefinition } = data;
+      if (goalDefinition != null) {
+        showSuccessToast('New Scheduling Goal Revision Created Successfully');
+        return goalDefinition;
+      } else {
+        throw Error(`Unable to create goal definition for scheduling goal "${goalId}"`);
+      }
     } catch (e) {
-      catchError(e as Error);
+      catchError('Scheduling Goal Creation Failed', e as Error);
+      showFailureToast('Scheduling Goal Creation Failed');
       return null;
     }
   },
 
-  async createSchedulingSpecCondition(
-    spec_condition: SchedulingSpecConditionInsertInput,
+  // async createSchedulingGoalPlanSpecification(
+  //   spec_goal: SchedulingSpecGoalInsertInput,
+  //   user: User | null,
+  // ): Promise<number | null> {
+  //   try {
+  //     if (!queryPermissions.CREATE_SCHEDULING_GOAL_PLAN_SPECIFICATION(user)) {
+  //       throwPermissionError('create a scheduling spec goal');
+  //     }
+
+  //     const data = await reqHasura<SchedulingGoalPlanSpecification>(
+  //       gql.CREATE_SCHEDULING_GOAL_PLAN_SPECIFICATION,
+  //       { spec_goal },
+  //       user,
+  //     );
+  //     const { createSchedulingSpecGoal } = data;
+  //     if (createSchedulingSpecGoal != null) {
+  //       const { specification_id } = createSchedulingSpecGoal;
+  //       return specification_id;
+  //     } else {
+  //       throw Error('Unable to create a scheduling spec goal');
+  //     }
+  //   } catch (e) {
+  //     catchError(e as Error);
+  //     return null;
+  //   }
+  // },
+
+  async createSchedulingPlanSpecification(
+    spec: SchedulingPlanSpecificationInsertInput,
     user: User | null,
-  ): Promise<void> {
+  ): Promise<Pick<SchedulingPlanSpecification, 'id'> | null> {
     try {
-      if (!queryPermissions.CREATE_SCHEDULING_SPEC_CONDITION(user)) {
-        throwPermissionError('create a scheduling spec condition');
+      if (!queryPermissions.CREATE_SCHEDULING_SPEC(user)) {
+        throwPermissionError('create a scheduling spec');
       }
 
-      const data = await reqHasura<SchedulingSpecCondition>(
-        gql.CREATE_SCHEDULING_SPEC_CONDITION,
-        { spec_condition },
+      const data = await reqHasura<Pick<SchedulingPlanSpecification, 'id'>>(
+        gql.CREATE_SCHEDULING_PLAN_SPECIFICATION,
+        { spec },
         user,
       );
-      if (data.createSchedulingSpecCondition == null) {
-        throw Error('Unable to create a scheduling spec condition');
-      }
-    } catch (e) {
-      catchError(e as Error);
-    }
-  },
-
-  async createSchedulingSpecGoal(spec_goal: SchedulingSpecGoalInsertInput, user: User | null): Promise<number | null> {
-    try {
-      if (!queryPermissions.CREATE_SCHEDULING_SPEC_GOAL(user)) {
-        throwPermissionError('create a scheduling spec goal');
-      }
-
-      const data = await reqHasura<SchedulingSpecGoal>(gql.CREATE_SCHEDULING_SPEC_GOAL, { spec_goal }, user);
-      const { createSchedulingSpecGoal } = data;
-      if (createSchedulingSpecGoal != null) {
-        const { specification_id } = createSchedulingSpecGoal;
-        return specification_id;
-      } else {
-        throw Error('Unable to create a scheduling spec goal');
-      }
+      const { createSchedulingSpec: newSchedulingSpec } = data;
+      return newSchedulingSpec;
     } catch (e) {
       catchError(e as Error);
       return null;
@@ -2054,13 +2156,9 @@ const effects = {
     }
   },
 
-  async deleteSchedulingCondition(
-    condition: SchedulingCondition,
-    plan: PlanSchedulingSpec | null,
-    user: User | null,
-  ): Promise<boolean> {
+  async deleteSchedulingCondition(condition: SchedulingConditionMetadata, user: User | null): Promise<boolean> {
     try {
-      if (!queryPermissions.DELETE_SCHEDULING_CONDITION(user, plan, condition)) {
+      if (!queryPermissions.DELETE_SCHEDULING_CONDITION_METADATA(user, condition)) {
         throwPermissionError('delete this scheduling condition');
       }
 
@@ -2071,8 +2169,12 @@ const effects = {
       );
 
       if (confirm) {
-        const data = await reqHasura<{ id: number }>(gql.DELETE_SCHEDULING_CONDITION, { id: condition.id }, user);
-        if (data.deleteSchedulingCondition != null) {
+        const data = await reqHasura<{ id: number }>(
+          gql.DELETE_SCHEDULING_CONDITION_METADATA,
+          { id: condition.id },
+          user,
+        );
+        if (data.deleteSchedulingConditionMetadata != null) {
           showSuccessToast('Scheduling Condition Deleted Successfully');
           return true;
         } else {
@@ -2088,13 +2190,37 @@ const effects = {
     }
   },
 
-  async deleteSchedulingGoal(
-    goal: SchedulingGoalSlim,
-    plan: PlanSchedulingSpec | null,
-    user: User | null,
-  ): Promise<boolean> {
+  async deleteSchedulingConditionTags(ids: Tag['id'][], user: User | null): Promise<number | null> {
+    try {
+      if (!queryPermissions.DELETE_SCHEDULING_CONDITION_METADATA_TAGS(user)) {
+        throwPermissionError('delete scheduling condition tags');
+      }
+
+      const data = await reqHasura<{ affected_rows: number }>(
+        gql.DELETE_SCHEDULING_CONDITION_METADATA_TAGS,
+        { ids },
+        user,
+      );
+      const { delete_scheduling_condition_tags } = data;
+      if (delete_scheduling_condition_tags != null) {
+        const { affected_rows } = delete_scheduling_condition_tags;
+        if (affected_rows !== ids.length) {
+          throw Error('Some scheduling condition tags were not successfully created');
+        }
+        return affected_rows;
+      } else {
+        throw Error('Unable to delete scheduling condition tags');
+      }
+    } catch (e) {
+      catchError('Delete Scheduling Condition Tags Failed', e as Error);
+      showFailureToast('Delete Scheduling Condition Tags Failed');
+      return null;
+    }
+  },
+
+  async deleteSchedulingGoal(goal: SchedulingGoalMetadata, user: User | null): Promise<boolean> {
     try {
-      if (!queryPermissions.DELETE_SCHEDULING_GOAL(user, plan)) {
+      if (!queryPermissions.DELETE_SCHEDULING_GOAL_METADATA(user, goal)) {
         throwPermissionError('delete this scheduling goal');
       }
 
@@ -2105,9 +2231,9 @@ const effects = {
       );
 
       if (confirm) {
-        const data = await reqHasura<{ id: number }>(gql.DELETE_SCHEDULING_GOAL, { id: goal.id }, user);
+        const data = await reqHasura<{ id: number }>(gql.DELETE_SCHEDULING_GOAL_METADATA, { id: goal.id }, user);
 
-        if (data.deleteSchedulingGoal) {
+        if (data.deleteSchedulingGoalMetadata) {
           showSuccessToast('Scheduling Goal Deleted Successfully');
           return true;
         } else {
@@ -2125,11 +2251,11 @@ const effects = {
 
   async deleteSchedulingGoalTags(ids: Tag['id'][], user: User | null): Promise<number | null> {
     try {
-      if (!queryPermissions.DELETE_SCHEDULING_GOAL_TAGS(user)) {
+      if (!queryPermissions.DELETE_SCHEDULING_GOAL_METADATA_TAGS(user)) {
         throwPermissionError('delete scheduling goal tags');
       }
 
-      const data = await reqHasura<{ affected_rows: number }>(gql.DELETE_SCHEDULING_GOAL_TAGS, { ids }, user);
+      const data = await reqHasura<{ affected_rows: number }>(gql.DELETE_SCHEDULING_GOAL_METADATA_TAGS, { ids }, user);
       const { delete_scheduling_goal_tags } = data;
       if (delete_scheduling_goal_tags != null) {
         const { affected_rows } = delete_scheduling_goal_tags;
@@ -2147,28 +2273,28 @@ const effects = {
     }
   },
 
-  async deleteSchedulingSpecGoal(goal_id: number, specification_id: number, user: User | null): Promise<boolean> {
-    try {
-      if (!queryPermissions.DELETE_SCHEDULING_SPEC_GOAL(user)) {
-        throwPermissionError('delete this scheduling goal');
-      }
-
-      const data = await reqHasura<{ goal_id: number; specification_id: number }>(
-        gql.DELETE_SCHEDULING_SPEC_GOAL,
-        { goal_id, specification_id },
-        user,
-      );
-      if (data.deleteSchedulingSpecGoal != null) {
-        return true;
-      } else {
-        throw Error(`Unable to delete scheduling goal with ID: "${goal_id}"`);
-      }
-    } catch (e) {
-      catchError('Scheduling Goal Delete Failed', e as Error);
-      showFailureToast('Scheduling Goal Delete Failed');
-      return false;
-    }
-  },
+  // async deleteSchedulingSpecGoal(goal_id: number, specification_id: number, user: User | null): Promise<boolean> {
+  //   try {
+  //     if (!queryPermissions.DELETE_SCHEDULING_GOAL_PLAN_SPECIFICATION(user)) {
+  //       throwPermissionError('delete this scheduling goal');
+  //     }
+
+  //     const data = await reqHasura<{ goal_id: number; specification_id: number }>(
+  //       gql.DELETE_SCHEDULING_SPEC_GOAL,
+  //       { goal_id, specification_id },
+  //       user,
+  //     );
+  //     if (data.deleteSchedulingSpecGoal != null) {
+  //       return true;
+  //     } else {
+  //       throw Error(`Unable to delete scheduling goal with ID: "${goal_id}"`);
+  //     }
+  //   } catch (e) {
+  //     catchError('Scheduling Goal Delete Failed', e as Error);
+  //     showFailureToast('Scheduling Goal Delete Failed');
+  //     return false;
+  //   }
+  // },
 
   async deleteSimulationTemplate(
     simulationTemplate: SimulationTemplate,
@@ -2873,24 +2999,6 @@ const effects = {
     }
   },
 
-  async getPlansAndModelsForScheduling(user: User | null): Promise<{
-    models: ModelSlim[];
-    plans: PlanSchedulingSpec[];
-  }> {
-    try {
-      const data = (await reqHasura(gql.GET_PLANS_AND_MODELS_FOR_SCHEDULING, {}, user)) as {
-        models: ModelSlim[];
-        plans: PlanSchedulingSpec[];
-      };
-
-      const { models, plans } = data;
-      return { models, plans };
-    } catch (e) {
-      catchError(e as Error);
-      return { models: [], plans: [] };
-    }
-  },
-
   getResource(
     datasetId: number,
     name: string,
@@ -2997,32 +3105,42 @@ const effects = {
     }
   },
 
-  async getSchedulingCondition(id: number | null | undefined, user: User | null): Promise<SchedulingCondition | null> {
-    if (id !== null && id !== undefined) {
-      try {
-        const data = await reqHasura<SchedulingCondition>(gql.GET_SCHEDULING_CONDITION, { id }, user);
-        const { condition } = data;
-        return condition;
-      } catch (e) {
-        catchError(e as Error);
-        return null;
+  async getSchedulingCondition(id: number, user: User | null): Promise<SchedulingConditionMetadata | null> {
+    try {
+      const data = await reqHasura<SchedulingConditionMetadataResponse>(
+        convertToQuery(gql.SUB_SCHEDULING_CONDITION),
+        { id },
+        user,
+      );
+      const tags = await effects.getTags(user);
+      const { condition } = data;
+
+      if (condition) {
+        return convertResponseToMetadata(condition, tags);
       }
-    } else {
+      return condition;
+    } catch (e) {
+      catchError(e as Error);
       return null;
     }
   },
 
-  async getSchedulingGoal(id: number | null | undefined, user: User | null): Promise<SchedulingGoal | null> {
-    if (id !== null && id !== undefined) {
-      try {
-        const data = await reqHasura<SchedulingGoal>(gql.GET_SCHEDULING_GOAL, { id }, user);
-        const { goal } = data;
-        return goal;
-      } catch (e) {
-        catchError(e as Error);
-        return null;
+  async getSchedulingGoal(id: number, user: User | null): Promise<SchedulingGoalMetadata | null> {
+    try {
+      const data = await reqHasura<SchedulingGoalMetadataResponse>(
+        convertToQuery(gql.SUB_SCHEDULING_GOAL),
+        { id },
+        user,
+      );
+      const tags = await effects.getTags(user);
+      const { goal } = data;
+
+      if (goal) {
+        return convertResponseToMetadata(goal, tags);
       }
-    } else {
+      return goal;
+    } catch (e) {
+      catchError(e as Error);
       return null;
     }
   },
@@ -3030,10 +3148,10 @@ const effects = {
   async getSchedulingSpecConditionsForCondition(
     condition_id: number | null,
     user: User | null,
-  ): Promise<SchedulingSpecCondition[] | null> {
+  ): Promise<SchedulingConditionPlanSpecification[] | null> {
     if (condition_id !== null) {
       try {
-        const data = await reqHasura<SchedulingSpecCondition[]>(
+        const data = await reqHasura<SchedulingConditionPlanSpecification[]>(
           gql.GET_SCHEDULING_SPEC_CONDITIONS_FOR_CONDITION,
           {
             condition_id,
@@ -3051,10 +3169,17 @@ const effects = {
     }
   },
 
-  async getSchedulingSpecGoalsForGoal(goal_id: number | null, user: User | null): Promise<SchedulingSpecGoal[] | null> {
+  async getSchedulingSpecGoalsForGoal(
+    goal_id: number | null,
+    user: User | null,
+  ): Promise<SchedulingGoalPlanSpecification[] | null> {
     if (goal_id !== null) {
       try {
-        const data = await reqHasura<SchedulingSpecGoal[]>(gql.GET_SCHEDULING_SPEC_GOALS_FOR_GOAL, { goal_id }, user);
+        const data = await reqHasura<SchedulingGoalPlanSpecification[]>(
+          gql.GET_SCHEDULING_SPEC_GOALS_FOR_GOAL,
+          { goal_id },
+          user,
+        );
         const { scheduling_specification_goals } = data;
         return scheduling_specification_goals;
       } catch (e) {
@@ -3472,6 +3597,24 @@ const effects = {
     }
   },
 
+  async managePlanSchedulingConditions(user: User | null): Promise<void> {
+    try {
+      await showManagePlanSchedulingConditionsModal(user);
+    } catch (e) {
+      catchError('Scheduling Condition Unable To Be Applied To Plan', e as Error);
+      showFailureToast('Scheduling Condition Application Failed');
+    }
+  },
+
+  async managePlanSchedulingGoals(user: User | null): Promise<void> {
+    try {
+      await showManagePlanSchedulingGoalsModal(user);
+    } catch (e) {
+      catchError('Scheduling Goal Unable To Be Applied To Plan', e as Error);
+      showFailureToast('Scheduling Goal Application Failed');
+    }
+  },
+
   async planMergeBegin(
     merge_request_id: number,
     sourcePlan: PlanForMerging,
@@ -3751,7 +3894,7 @@ const effects = {
     try {
       if (plan) {
         if (
-          !queryPermissions.UPDATE_SCHEDULING_SPEC(user, plan) ||
+          !queryPermissions.UPDATE_SCHEDULING_PLAN_SPECIFICATIONS(user, plan) ||
           !queryPermissions.SCHEDULE(user, plan, plan.model)
         ) {
           throwPermissionError(`run ${analysis_only ? 'scheduling analysis' : 'scheduling'}`);
@@ -4049,9 +4192,9 @@ const effects = {
       );
 
       if (updateConstraintPlanSpecification !== null) {
-        showSuccessToast(`Constraints Updated Successfully`);
+        showSuccessToast(`Constraint Plan Specification Updated Successfully`);
       } else {
-        throw Error('Unable to update the constraints for the plan');
+        throw Error('Unable to update the constraint specification for the plan');
       }
     } catch (e) {
       catchError('Constraint Plan Specification Update Failed', e as Error);
@@ -4077,13 +4220,13 @@ const effects = {
       );
 
       if (updateConstraintPlanSpecifications !== null || deleteConstraintPlanSpecifications !== null) {
-        showSuccessToast(`Constraints Updated Successfully`);
+        showSuccessToast(`Constraint Plan Specifications Updated Successfully`);
       } else {
-        throw Error('Unable to update the constraints for the plan');
+        throw Error('Unable to update the constraint specifications for the plan');
       }
     } catch (e) {
-      catchError('Constraint Plan Specification Update Failed', e as Error);
-      showFailureToast('Constraint Plan Specification Update Failed');
+      catchError('Constraint Plan Specifications Update Failed', e as Error);
+      showFailureToast('Constraint Plan Specifications Update Failed');
     }
   },
 
@@ -4137,157 +4280,314 @@ const effects = {
     }
   },
 
-  async updateSchedulingCondition(
-    id: number,
-    condition: Partial<SchedulingCondition>,
-    plan: PlanSchedulingSpec,
+  async updateSchedulingConditionDefinitionTags(
+    conditionId: number,
+    conditionRevision: number,
+    tags: SchedulingConditionDefinitionTagsInsertInput[],
+    tagIdsToDelete: number[],
     user: User | null,
-  ): Promise<Pick<SchedulingCondition, 'id' | 'last_modified_by' | 'modified_date'> | null> {
+  ): Promise<number | null> {
     try {
-      if (!queryPermissions.UPDATE_SCHEDULING_CONDITION(user, plan)) {
-        throwPermissionError('update this scheduling condition');
+      if (!queryPermissions.UPDATE_SCHEDULING_CONDITION_DEFINITION_TAGS(user)) {
+        throwPermissionError('create scheduling condition definition tags');
       }
 
-      const data = await reqHasura(gql.UPDATE_SCHEDULING_CONDITION, { condition, id }, user);
-      const { updateSchedulingCondition: updatedCondition } = data;
+      const data = await reqHasura<{ affected_rows: number }>(
+        gql.UPDATE_SCHEDULING_CONDITION_DEFINITION_TAGS,
+        { conditionId, conditionRevision, tagIdsToDelete, tags },
+        user,
+      );
+      const { deleteSchedulingConditionDefinitionTags, insertSchedulingConditionDefinitionTags } = data;
+      if (insertSchedulingConditionDefinitionTags != null && deleteSchedulingConditionDefinitionTags != null) {
+        const { affected_rows } = insertSchedulingConditionDefinitionTags;
 
-      if (updatedCondition != null) {
         showSuccessToast('Scheduling Condition Updated Successfully');
-        return updatedCondition;
+
+        return affected_rows;
       } else {
-        throw Error(`Unable to update scheduling condition with ID: "${id}"`);
+        throw Error('Unable to create scheduling condition definition tags');
       }
     } catch (e) {
-      catchError('Scheduling Condition Update Failed', e as Error);
-      showFailureToast('Scheduling Condition Update Failed');
+      catchError('Create Scheduling Condition Definition Tags Failed', e as Error);
+      showFailureToast('Create Scheduling Condition Definition Tags Failed');
       return null;
     }
   },
 
-  async updateSchedulingGoal(
+  async updateSchedulingConditionMetadata(
     id: number,
-    goal: Partial<SchedulingGoal>,
-    plan: Pick<PlanSchedulingSpec, 'id' | 'name' | 'owner' | 'model_id' | 'collaborators'>,
+    conditionMetadata: SchedulingConditionMetadataSetInput,
+    tags: SchedulingConditionMetadataTagsInsertInput[],
+    tagIdsToDelete: number[],
+    currentConditionOwner: UserId,
     user: User | null,
-  ): Promise<Pick<SchedulingGoal, 'id' | 'last_modified_by' | 'modified_date'> | null> {
+  ): Promise<boolean> {
     try {
-      if (!queryPermissions.UPDATE_SCHEDULING_GOAL(user, plan)) {
-        throwPermissionError('update this scheduling goal');
+      if (!queryPermissions.UPDATE_SCHEDULING_CONDITION_METADATA(user, { owner: currentConditionOwner })) {
+        throwPermissionError('update this scheduling condition');
       }
 
-      const data = await reqHasura(gql.UPDATE_SCHEDULING_GOAL, { goal, id }, user);
-      const { updateSchedulingGoal: updatedGoal } = data;
+      const data = await reqHasura(
+        gql.UPDATE_SCHEDULING_CONDITION_METADATA,
+        { conditionMetadata, id, tagIdsToDelete, tags },
+        user,
+      );
+      if (
+        data.updateSchedulingConditionMetadata == null ||
+        data.insertSchedulingConditionTags == null ||
+        data.deleteSchedulingConditionTags == null
+      ) {
+        throw Error(`Unable to update scheduling condition metadata with ID: "${id}"`);
+      }
 
-      if (updatedGoal != null) {
-        showSuccessToast('Scheduling Goal Updated Successfully');
-        return updatedGoal;
+      showSuccessToast('Scheduling Condition Updated Successfully');
+      return true;
+    } catch (e) {
+      catchError('Scheduling Condition Metadata Update Failed', e as Error);
+      showFailureToast('Scheduling Condition Metadata Update Failed');
+      return false;
+    }
+  },
+
+  async updateSchedulingConditionPlanSpecification(
+    plan: Plan,
+    schedulingSpecificationId: number,
+    schedulingConditionPlanSpecification: SchedulingConditionPlanSpecInsertInput,
+    user: User | null,
+  ) {
+    try {
+      if (!queryPermissions.UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATIONS(user, plan)) {
+        throwPermissionError('update this scheduling condition plan specification');
+      }
+      const { enabled, condition_id: conditionId, condition_revision: revision } = schedulingConditionPlanSpecification;
+
+      const { updateSchedulingConditionPlanSpecification } = await reqHasura(
+        gql.UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION,
+        { enabled, id: conditionId, revision, specificationId: schedulingSpecificationId },
+        user,
+      );
+
+      if (updateSchedulingConditionPlanSpecification !== null) {
+        showSuccessToast(`Scheduling Condition Plan Specification Updated Successfully`);
       } else {
-        throw Error(`Unable to update scheduling goal with ID: "${id}"`);
+        throw Error('Unable to update the scheduling condition specification for the plan');
       }
     } catch (e) {
-      catchError('Scheduling Goal Update Failed', e as Error);
-      showFailureToast('Scheduling Goal Update Failed');
-      return null;
+      catchError('Scheduling Condition Plan Specification Update Failed', e as Error);
+      showFailureToast('Scheduling Condition Plan Specification Update Failed');
     }
   },
 
-  async updateSchedulingSpec(id: number, spec: Partial<SchedulingSpec>, plan: Plan, user: User | null): Promise<void> {
+  async updateSchedulingConditionPlanSpecifications(
+    plan: Plan,
+    schedulingSpecificationId: number,
+    conditionSpecsToUpdate: SchedulingConditionPlanSpecInsertInput[],
+    conditionSpecIdsToDelete: number[],
+    user: User | null,
+  ) {
     try {
-      if (!queryPermissions.UPDATE_SCHEDULING_SPEC(user, plan)) {
-        throwPermissionError('update this scheduling spec');
+      if (!queryPermissions.UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATIONS(user, plan)) {
+        throwPermissionError('update this scheduling condition plan specification');
       }
+      const { deleteConstraintPlanSpecifications, updateSchedulingConditionPlanSpecifications } = await reqHasura(
+        gql.UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATIONS,
+        {
+          conditionSpecIdsToDelete,
+          conditionSpecsToUpdate,
+          specificationId: schedulingSpecificationId,
+        },
+        user,
+      );
 
-      const data = await reqHasura(gql.UPDATE_SCHEDULING_SPEC, { id, spec }, user);
-      if (data.updateSchedulingSpec == null) {
-        throw Error(`Unable to update scheduling spec with ID: "${id}"`);
+      if (updateSchedulingConditionPlanSpecifications !== null || deleteConstraintPlanSpecifications !== null) {
+        showSuccessToast(`Scheduling Conditions Updated Successfully`);
+      } else {
+        throw Error('Unable to update the scheduling condition specifications for the plan');
       }
     } catch (e) {
-      catchError(e as Error);
+      catchError('Scheduling Condition Plan Specifications Update Failed', e as Error);
+      showFailureToast('Scheduling Condition Plan Specifications Update Failed');
     }
   },
 
-  async updateSchedulingSpecCondition(
-    condition_id: number,
-    specification_id: number,
-    spec_condition: Partial<SchedulingSpecCondition>,
+  async updateSchedulingGoalDefinitionTags(
+    goalId: number,
+    goalRevision: number,
+    tags: SchedulingGoalDefinitionTagsInsertInput[],
+    tagIdsToDelete: number[],
     user: User | null,
-  ): Promise<void> {
+  ): Promise<number | null> {
     try {
-      if (!queryPermissions.UPDATE_SCHEDULING_SPEC_CONDITION_ID(user)) {
-        throwPermissionError('update this scheduling spec condition');
+      if (!queryPermissions.UPDATE_SCHEDULING_GOAL_DEFINITION_TAGS(user)) {
+        throwPermissionError('create scheduling condition definition tags');
       }
 
-      const data = await reqHasura(
-        gql.UPDATE_SCHEDULING_SPEC_CONDITION,
-        { condition_id, spec_condition, specification_id },
+      const data = await reqHasura<{ affected_rows: number }>(
+        gql.UPDATE_SCHEDULING_GOAL_DEFINITION_TAGS,
+        { goalId, goalRevision, tagIdsToDelete, tags },
         user,
       );
-      if (data.updateSchedulingSpecCondition != null) {
-        showSuccessToast('Scheduling Spec Condition Updated Successfully');
+      const { deleteSchedulingGoalDefinitionTags, insertSchedulingGoalDefinitionTags } = data;
+      if (insertSchedulingGoalDefinitionTags != null && deleteSchedulingGoalDefinitionTags != null) {
+        const { affected_rows } = insertSchedulingGoalDefinitionTags;
+
+        showSuccessToast('Scheduling Goal Updated Successfully');
+
+        return affected_rows;
       } else {
-        throw Error(`Unable to update scheduling spec condition with ID: "${condition_id}"`);
+        throw Error('Unable to create scheduling condition definition tags');
       }
     } catch (e) {
-      catchError('Scheduling Spec Condition Update Failed', e as Error);
-      showFailureToast('Scheduling Spec Condition Update Failed');
+      catchError('Create Scheduling Goal Definition Tags Failed', e as Error);
+      showFailureToast('Create Scheduling Goal Definition Tags Failed');
+      return null;
     }
   },
 
-  async updateSchedulingSpecConditionId(
-    condition_id: number,
-    specification_id: number,
-    new_specification_id: number,
+  async updateSchedulingGoalMetadata(
+    id: number,
+    goalMetadata: SchedulingGoalMetadataSetInput,
+    tags: SchedulingGoalMetadataTagsInsertInput[],
+    tagIdsToDelete: number[],
+    currentGoalOwner: UserId,
     user: User | null,
   ): Promise<void> {
     try {
-      if (!queryPermissions.UPDATE_SCHEDULING_SPEC_CONDITION_ID(user)) {
-        throwPermissionError('update this scheduling spec condition');
+      if (!queryPermissions.UPDATE_SCHEDULING_GOAL_METADATA(user, { owner: currentGoalOwner })) {
+        throwPermissionError('update this scheduling goal');
       }
 
       const data = await reqHasura(
-        gql.UPDATE_SCHEDULING_SPEC_CONDITION_ID,
+        gql.UPDATE_SCHEDULING_GOAL_METADATA,
+        { goalMetadata, id, tagIdsToDelete, tags },
+        user,
+      );
+      if (
+        data.updateSchedulingGoalMetadata == null ||
+        data.insertSchedulingGoalTags == null ||
+        data.deleteSchedulingGoalTags == null
+      ) {
+        throw Error(`Unable to update scheduling goal metadata with ID: "${id}"`);
+      }
+
+      showSuccessToast('Scheduling Goal Updated Successfully');
+    } catch (e) {
+      catchError('Scheduling Goal Metadata Update Failed', e as Error);
+      showFailureToast('Scheduling Goal Metadata Update Failed');
+    }
+  },
+
+  async updateSchedulingGoalPlanSpecification(
+    plan: Plan,
+    schedulingSpecificationId: number,
+    schedulingGoalPlanSpecification: SchedulingGoalPlanSpecInsertInput,
+    user: User | null,
+  ) {
+    try {
+      if (!queryPermissions.UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATION(user, plan)) {
+        throwPermissionError('update this scheduling goal plan specification');
+      }
+      const {
+        enabled,
+        goal_id: goalId,
+        goal_revision: revision,
+        priority,
+        simulate_after: simulateAfter,
+      } = schedulingGoalPlanSpecification;
+
+      const { updateSchedulingGoalPlanSpecification } = await reqHasura(
+        gql.UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATION,
+        { enabled, id: goalId, priority, revision, simulateAfter, specificationId: schedulingSpecificationId },
+        user,
+      );
+
+      if (updateSchedulingGoalPlanSpecification !== null) {
+        showSuccessToast(`Scheduling Goal Plan Specification Updated Successfully`);
+      } else {
+        throw Error('Unable to update the scheduling goal specification for the plan');
+      }
+    } catch (e) {
+      catchError('Scheduling Goal Plan Specification Update Failed', e as Error);
+      showFailureToast('Scheduling Goal Plan Specification Update Failed');
+    }
+  },
+
+  async updateSchedulingGoalPlanSpecifications(
+    plan: Plan,
+    schedulingSpecificationId: number,
+    goalSpecsToUpdate: SchedulingGoalPlanSpecInsertInput[],
+    goalSpecIdsToDelete: number[],
+    user: User | null,
+  ) {
+    try {
+      if (!queryPermissions.UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATIONS(user, plan)) {
+        throwPermissionError('update this scheduling goal plan specification');
+      }
+      const { deleteConstraintPlanSpecifications, updateSchedulingGoalPlanSpecifications } = await reqHasura(
+        gql.UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATIONS,
         {
-          condition_id,
-          new_specification_id,
-          specification_id,
+          goalSpecIdsToDelete,
+          goalSpecsToUpdate,
+          specificationId: schedulingSpecificationId,
         },
         user,
       );
-      if (data.updateSchedulingSpecConditionId != null) {
-        showSuccessToast('Scheduling Spec Condition Updated Successfully');
+
+      if (updateSchedulingGoalPlanSpecifications !== null || deleteConstraintPlanSpecifications !== null) {
+        showSuccessToast(`Scheduling Goals Updated Successfully`);
       } else {
-        throw Error(`Unable to update scheduling spec condition with ID: "${condition_id}"`);
+        throw Error('Unable to update the scheduling goal specifications for the plan');
       }
     } catch (e) {
-      catchError('Scheduling Spec Condition Update Failed', e as Error);
-      showFailureToast('Scheduling Spec Condition Update Failed');
+      catchError('Scheduling Goal Plan Specifications Update Failed', e as Error);
+      showFailureToast('Scheduling Goal Plan Specifications Update Failed');
     }
   },
 
-  async updateSchedulingSpecGoal(
-    goal_id: number,
-    specification_id: number,
-    spec_goal: Partial<SchedulingSpecGoal>,
+  async updateSchedulingSpec(
+    id: number,
+    spec: Partial<SchedulingPlanSpecification>,
     plan: Plan,
     user: User | null,
   ): Promise<void> {
     try {
-      if (!queryPermissions.UPDATE_SCHEDULING_SPEC_GOAL(user, plan)) {
-        throwPermissionError('update this scheduling spec goal');
+      if (!queryPermissions.UPDATE_SCHEDULING_PLAN_SPECIFICATIONS(user, plan)) {
+        throwPermissionError('update this scheduling spec');
       }
 
-      const data = await reqHasura(gql.UPDATE_SCHEDULING_SPEC_GOAL, { goal_id, spec_goal, specification_id }, user);
-      if (data.updateSchedulingSpecGoal != null) {
-        showSuccessToast('Scheduling Spec Goal Updated Successfully');
-      } else {
-        throw Error(`Unable to update scheduling spec goal with ID: "${goal_id}"`);
+      const data = await reqHasura(gql.UPDATE_SCHEDULING_SPEC, { id, spec }, user);
+      if (data.updateSchedulingSpec == null) {
+        throw Error(`Unable to update scheduling spec with ID: "${id}"`);
       }
     } catch (e) {
-      catchError('Scheduling Spec Goal Update Failed', e as Error);
-      showFailureToast('Scheduling Spec Goal Update Failed');
+      catchError(e as Error);
     }
   },
 
+  // async updateSchedulingSpecGoal(
+  //   goal_id: number,
+  //   specification_id: number,
+  //   spec_goal: Partial<SchedulingGoalPlanSpecification>,
+  //   plan: Plan,
+  //   user: User | null,
+  // ): Promise<void> {
+  //   try {
+  //     if (!queryPermissions.UPDATE_SCHEDULING_SPEC_GOAL(user, plan)) {
+  //       throwPermissionError('update this scheduling spec goal');
+  //     }
+
+  //     const data = await reqHasura(gql.UPDATE_SCHEDULING_SPEC_GOAL, { goal_id, spec_goal, specification_id }, user);
+  //     if (data.updateSchedulingSpecGoal != null) {
+  //       showSuccessToast('Scheduling Spec Goal Updated Successfully');
+  //     } else {
+  //       throw Error(`Unable to update scheduling spec goal with ID: "${goal_id}"`);
+  //     }
+  //   } catch (e) {
+  //     catchError('Scheduling Spec Goal Update Failed', e as Error);
+  //     showFailureToast('Scheduling Spec Goal Update Failed');
+  //   }
+  // },
+
   async updateSimulation(
     plan: Plan,
     simulationSetInput: Simulation,
diff --git a/src/utilities/gql.ts b/src/utilities/gql.ts
index 6d8d8d0702..0ea4b47b66 100644
--- a/src/utilities/gql.ts
+++ b/src/utilities/gql.ts
@@ -153,7 +153,7 @@ const gql = {
   `,
 
   CREATE_CONSTRAINT_DEFINITION: `#graphql
-    mutation insertConstraintDefinition($constraintDefinition: constraint_definition_insert_input!) {
+    mutation CreateConstraintDefinition($constraintDefinition: constraint_definition_insert_input!) {
       constraintDefinition: insert_constraint_definition_one(object: $constraintDefinition) {
         constraint_id
         definition
@@ -277,68 +277,83 @@ const gql = {
         affected_rows
       }
     }
-`,
+  `,
 
   CREATE_SCHEDULING_CONDITION: `#graphql
-    mutation CreateSchedulingCondition($condition: scheduling_condition_insert_input!) {
-      createSchedulingCondition: insert_scheduling_condition_one(object: $condition) {
-        created_date
-        definition
-        description
+    mutation CreateSchedulingCondition($condition: scheduling_condition_metadata_insert_input!) {
+      createSchedulingCondition: insert_scheduling_condition_metadata_one(object: $condition) {
         id
-        model_id
-        modified_date
         name
-        revision
+        description
+        owner
+        public
+        tags {
+          tag_id
+        }
+        versions {
+          revision
+          definition
+          tags {
+            tag_id
+          }
+        }
       }
     }
   `,
 
-  CREATE_SCHEDULING_GOAL: `#graphql
-    mutation CreateSchedulingGoal($goal: scheduling_goal_insert_input!) {
-      createSchedulingGoal: insert_scheduling_goal_one(object: $goal) {
-        created_date
+  CREATE_SCHEDULING_CONDITION_DEFINITION: `#graphql
+    mutation CreateSchedulingConditionDefinition($conditionDefinition: scheduling_condition_definition_insert_input!) {
+      conditionDefinition: insert_scheduling_condition_definition_one(object: $conditionDefinition) {
+        condition_id
         definition
-        description
-        id
-        model_id
-        modified_date
-        name
         revision
       }
     }
   `,
 
-  CREATE_SCHEDULING_GOAL_TAGS: `#graphql
-    mutation CreateSchedulingGoalTags($tags: [scheduling_goal_tags_insert_input!]!) {
-      insert_scheduling_goal_tags(objects: $tags, on_conflict: {
-        constraint: scheduling_goal_tags_pkey,
-        update_columns: []
-      }) {
-        affected_rows
+  CREATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION: `#graphql
+    mutation CreateSchedulingSpecCondition($spec_condition: scheduling_specification_conditions_insert_input!) {
+      createSchedulingSpecCondition: insert_scheduling_specification_conditions_one(object: $spec_condition) {
+        enabled
+        condition_id
+        specification_id
       }
     }
   `,
 
-  CREATE_SCHEDULING_SPEC: `#graphql
-    mutation CreateSchedulingSpec($spec: scheduling_specification_insert_input!) {
-      createSchedulingSpec: insert_scheduling_specification_one(object: $spec) {
+  CREATE_SCHEDULING_GOAL: `#graphql
+    mutation CreateSchedulingGoal($goal: scheduling_goal_metadata_insert_input!) {
+      createSchedulingGoal: insert_scheduling_goal_metadata_one(object: $goal) {
         id
+        name
+        description
+        owner
+        public
+        tags {
+          tag_id
+        }
+        versions {
+          revision
+          definition
+          tags {
+            tag_id
+          }
+        }
       }
     }
   `,
 
-  CREATE_SCHEDULING_SPEC_CONDITION: `#graphql
-    mutation CreateSchedulingSpecCondition($spec_condition: scheduling_specification_conditions_insert_input!) {
-      createSchedulingSpecCondition: insert_scheduling_specification_conditions_one(object: $spec_condition) {
-        enabled
-        condition_id
-        specification_id
+  CREATE_SCHEDULING_GOAL_DEFINITION: `#graphql
+    mutation CreateSchedulingGoalDefinition($goalDefinition: scheduling_goal_definition_insert_input!) {
+      goalDefinition: insert_scheduling_goal_definition_one(object: $goalDefinition) {
+        goal_id
+        definition
+        revision
       }
     }
   `,
 
-  CREATE_SCHEDULING_SPEC_GOAL: `#graphql
+  CREATE_SCHEDULING_GOAL_PLAN_SPECIFICATION: `#graphql
     mutation CreateSchedulingSpecGoal($spec_goal: scheduling_specification_goals_insert_input!) {
       createSchedulingSpecGoal: insert_scheduling_specification_goals_one(object: $spec_goal) {
         enabled
@@ -349,6 +364,14 @@ const gql = {
     }
   `,
 
+  CREATE_SCHEDULING_PLAN_SPECIFICATION: `#graphql
+    mutation CreateSchedulingSpec($spec: scheduling_specification_insert_input!) {
+      createSchedulingSpec: insert_scheduling_specification_one(object: $spec) {
+        id
+      }
+    }
+  `,
+
   CREATE_SIMULATION_TEMPLATE: `#graphql
     mutation CreateSimulationTemplate($simulationTemplateInsertInput: simulation_template_insert_input!) {
       insert_simulation_template_one(object: $simulationTemplateInsertInput) {
@@ -607,35 +630,94 @@ const gql = {
     }
   `,
 
-  DELETE_SCHEDULING_CONDITION: `#graphql
+  DELETE_SCHEDULING_CONDITION_METADATA: `#graphql
     mutation DeleteSchedulingCondition($id: Int!) {
-      deleteSchedulingCondition: delete_scheduling_condition_by_pk(id: $id) {
+      deleteSchedulingConditionMetadata: delete_scheduling_condition_metadata_by_pk(id: $id) {
         id
       }
     }
   `,
 
-  DELETE_SCHEDULING_GOAL: `#graphql
+  DELETE_SCHEDULING_CONDITION_METADATA_TAGS: `#graphql
+    mutation DeleteSchedulingConditionMetadataTags($ids: [Int!]!) {
+      delete_scheduling_condition_metadata_tags(where: { tag_id: { _in: $ids } }) {
+          affected_rows
+      }
+    }
+  `,
+
+  DELETE_SCHEDULING_CONDITION_MODEL_SPECIFICATIONS: `#graphql
+    mutation DeleteSchedulingConditionModelSpecification($conditionIds: [Int!]!, $modelId: Int!) {
+      delete_scheduling_condition_model_specification(
+        where: {
+          condition_id: { _in: $conditionIds },
+          _and: {
+            model_id: { _eq: $modelId },
+          }
+        }
+      ) {
+        affected_rows
+      }
+    }
+  `,
+
+  DELETE_SCHEDULING_CONDITION_PLAN_SPECIFICATIONS: `#graphql
+    mutation DeleteSchedulingConditionPlanSpecification($conditionIds: [Int!]!, $planId: Int!) {
+      delete_scheduling_specification_conditions(
+        where: {
+          condition_id: { _in: $conditionIds },
+          _and: {
+            plan_id: { _eq: $planId },
+          }
+        }
+      ) {
+        affected_rows
+      }
+    }
+  `,
+
+  DELETE_SCHEDULING_GOAL_METADATA: `#graphql
     mutation DeleteSchedulingGoal($id: Int!) {
-      deleteSchedulingGoal: delete_scheduling_goal_by_pk(id: $id) {
+      deleteSchedulingGoalMetadata: delete_scheduling_goal_metadata_by_pk(id: $id) {
         id
       }
     }
   `,
 
-  DELETE_SCHEDULING_GOAL_TAGS: `#graphql
-    mutation DeleteSchedulingGoalTags($ids: [Int!]!) {
-        delete_scheduling_goal_tags(where: { tag_id: { _in: $ids } }) {
+  DELETE_SCHEDULING_GOAL_METADATA_TAGS: `#graphql
+    mutation DeleteSchedulingGoalMetadataTags($ids: [Int!]!) {
+      delete_scheduling_goal_metadata_tags(where: { tag_id: { _in: $ids } }) {
           affected_rows
       }
     }
   `,
 
-  DELETE_SCHEDULING_SPEC_GOAL: `#graphql
-    mutation DeleteSchedulingSpecGoal($goal_id: Int!, $specification_id: Int!) {
-      deleteSchedulingSpecGoal: delete_scheduling_specification_goals_by_pk(goal_id: $goal_id, specification_id: $specification_id) {
-        goal_id,
-        specification_id,
+  DELETE_SCHEDULING_GOAL_MODEL_SPECIFICATIONS: `#graphql
+    mutation DeleteSchedulingGoalModelSpecification($goalIds: [Int!]!, $modelId: Int!) {
+      delete_scheduling_goal_model_specification(
+        where: {
+          goal_id: { _in: $goalIds },
+          _and: {
+            model_id: { _eq: $modelId },
+          }
+        }
+      ) {
+        affected_rows
+      }
+    }
+  `,
+
+  DELETE_SCHEDULING_GOAL_PLAN_SPECIFICATIONS: `#graphql
+    mutation DeleteSchedulingGoalPlanSpecification($goalIds: [Int!]!, $planId: Int!) {
+      delete_scheduling_specification_goal(
+        where: {
+          goal_id: { _in: $goalIds },
+          _and: {
+            plan_id: { _eq: $planId },
+          }
+        }
+      ) {
+        affected_rows
       }
     }
   `,
@@ -651,7 +733,7 @@ const gql = {
   DELETE_TAG: `#graphql
     mutation DeleteTags($id: Int!) {
       delete_tags_by_pk(id: $id) {
-          id
+        id
       }
     }
   `,
@@ -1164,50 +1246,6 @@ const gql = {
     }
   `,
 
-  GET_SCHEDULING_CONDITION: `#graphql
-    query GetSchedulingCondition($id: Int!) {
-      condition: scheduling_condition_by_pk(id: $id) {
-        author
-        created_date
-        definition
-        description
-        id
-        last_modified_by
-        model_id
-        modified_date
-        name
-        revision
-      }
-    }
-  `,
-
-  GET_SCHEDULING_GOAL: `#graphql
-    query GetSchedulingGoal($id: Int!) {
-      goal: scheduling_goal_by_pk(id: $id) {
-        analyses(limit: 0) {
-          analysis_id
-        }
-        author
-        created_date
-        definition
-        description
-        id
-        last_modified_by
-        model_id
-        modified_date
-        name
-        revision
-        tags {
-          tag {
-            color
-            id
-            name
-          }
-        }
-      }
-    }
-  `,
-
   GET_SCHEDULING_SPEC_CONDITIONS_FOR_CONDITION: `#graphql
     query GetSchedulingSpecConditionsForCondition($condition_id: Int!) {
       scheduling_specification_conditions(where: { condition_id: { _eq: $condition_id } }) {
@@ -2017,54 +2055,221 @@ const gql = {
     }
   `,
 
+  SUB_SCHEDULING_CONDITION: `#graphql
+    subscription SubSchedulingCondition($id: Int!) {
+      condition: scheduling_condition_metadata_by_pk(id: $id) {
+        created_at
+        description
+        id
+        name
+        models_using {
+          model_id
+        }
+        owner
+        plans_using {
+          specification {
+            plan_id
+          }
+        }
+        public
+        tags {
+          tag_id
+        }
+        updated_at
+        updated_by
+        versions {
+          author
+          definition
+          revision
+          tags {
+            tag_id
+          }
+        }
+      }
+    }
+  `,
+
   SUB_SCHEDULING_CONDITIONS: `#graphql
     subscription SubSchedulingConditions {
-      conditions: scheduling_condition(order_by: { id: desc }) {
-        author
-        created_date
-        definition
+      conditions: scheduling_condition_metadata(order_by: { name: asc }) {
+        created_at
         description
         id
-        last_modified_by
-        model_id
-        modified_date
         name
-        scheduling_specification_conditions {
-          specification_id
+        models_using {
+          model_id
+        }
+        owner
+        plans_using {
+          specification {
+            plan_id
+          }
+        }
+        public
+        tags {
+          tag_id
+        }
+        updated_at
+        updated_by
+        versions {
+          author
+          definition
+          revision
+          tags {
+            tag_id
+          }
+        }
+      }
+    }
+  `,
+
+  SUB_SCHEDULING_GOAL: `#graphql
+    subscription SubSchedulingGoal($id: Int!) {
+      goal: scheduling_goal_metadata_by_pk(id: $id) {
+        created_at
+        description
+        id
+        name
+        models_using {
+          model_id
+        }
+        owner
+        plans_using {
+          specification {
+            plan_id
+          }
+        }
+        public
+        tags {
+          tag_id
+        }
+        updated_at
+        updated_by
+        versions {
+          author
+          definition
+          revision
+          tags {
+            tag_id
+          }
         }
-        revision
       }
     }
   `,
 
   SUB_SCHEDULING_GOALS: `#graphql
     subscription SubSchedulingGoals {
-      goals: scheduling_goal(order_by: { id: desc }) {
-        analyses(limit: 0) {
+      goals: scheduling_goal_metadata(order_by: { name: asc }) {
+        analyses(order_by: { analysis_id: desc }) {
           analysis_id
+          goal_id
+          goal_revision
           request {
             specification_id
           }
+          satisfied
+          satisfying_activities {
+            activity_id
+          }
         }
-        author
-        created_date
-        definition
+        created_at
         description
         id
-        last_modified_by
-        model_id
-        modified_date
         name
-        scheduling_specification_goal {
-          specification_id
+        models_using {
+          model_id
+        }
+        owner
+        plans_using {
           specification {
             plan_id
           }
         }
-        revision
+        public
         tags {
           tag_id
         }
+        updated_at
+        updated_by
+        versions {
+          author
+          definition
+          revision
+          tags {
+            tag_id
+          }
+        }
+      }
+    }
+  `,
+
+  SUB_SCHEDULING_PLAN_SPECIFICATION: `#graphql
+    subscription SubSchedulingPlanSpecification($specificationId: Int!) {
+      schedulingPlanSpec: scheduling_specification_by_pk(id: $specificationId) {
+        analysis_only
+        horizon_end
+        horizon_start
+        id
+        plan_id
+        plan_revision
+        revision
+        simulation_arguments
+        conditions {
+          condition_id
+          condition_metadata {
+            name
+            owner
+            public
+            versions {
+              revision
+            }
+          }
+          condition_revision
+          enabled
+          specification_id
+        }
+        goals {
+          enabled
+          goal_definition {
+            analyses(order_by: { analysis_id: desc }) {
+              analysis_id
+              goal_id
+              goal_revision
+              request {
+                specification_id
+              }
+              satisfied
+              satisfying_activities {
+                activity_id
+              }
+            }
+          }
+          goal_id
+          goal_metadata {
+            name
+            owner
+            public
+            versions(order_by: {revision: desc}, limit: 1) {
+              analyses(order_by: { analysis_id: desc }) {
+                analysis_id
+                goal_id
+                goal_revision
+                request {
+                  specification_id
+                }
+                satisfied
+                satisfying_activities {
+                  activity_id
+                }
+              }
+              revision
+            }
+          }
+          goal_revision
+          priority
+          simulate_after
+          specification_id
+        }
       }
     }
   `,
@@ -2085,86 +2290,6 @@ const gql = {
     }
   `,
 
-  SUB_SCHEDULING_SPEC: `#graphql
-    subscription SubSchedulingSpec($planId: Int!) {
-      scheduling_specification(where: { plan_id: { _eq: $planId } }, limit: 1) {
-        id
-        revision
-        plan_id
-        plan_revision
-        analysis_only
-      }
-    }
-  `,
-
-  SUB_SCHEDULING_SPEC_CONDITIONS: `#graphql
-    subscription SubSchedulingSpecConditions($specification_id: Int!) {
-      specConditions: scheduling_specification_conditions(where: { specification_id: { _eq: $specification_id } }, order_by: { condition_id: asc }) {
-        enabled
-        condition {
-          author
-          created_date
-          definition
-          description
-          id
-          last_modified_by
-          model_id
-          modified_date
-          name
-          revision
-          scheduling_specification_conditions {
-            specification_id
-          }
-        }
-        specification {
-          analysis_only
-          horizon_end
-          horizon_start
-          id
-          plan_id
-          plan_revision
-          revision
-          simulation_arguments
-        }
-        specification_id
-      }
-    }
-  `,
-
-  SUB_SCHEDULING_SPEC_GOALS: `#graphql
-    subscription SubSchedulingSpecGoals($specification_id: Int!) {
-      specGoals: scheduling_specification_goals(where: { specification_id: { _eq: $specification_id } }, order_by: { priority: asc }) {
-        enabled
-        goal {
-          analyses(order_by: { request: { specification_revision: desc } }, limit: 2) {
-            analysis_id
-            satisfied
-            satisfying_activities {
-              activity_id
-            }
-            request {
-              specification_id
-            }
-          }
-          author
-          created_date
-          definition
-          description
-          description
-          id
-          last_modified_by
-          model_id
-          modified_date
-          name
-          revision
-        }
-        priority
-        simulate_after
-        specification_id
-      }
-    }
-  `,
-
   SUB_SIMULATION: `#graphql
     subscription SubSimulation($planId: Int!) {
       simulation(where: { plan_id: { _eq: $planId } }, order_by: { id: desc }, limit: 1) {
@@ -2282,7 +2407,7 @@ const gql = {
         owner
       }
     }
-`,
+  `,
 
   SUB_USER_SEQUENCES: `#graphql
     subscription SubUserSequences {
@@ -2463,26 +2588,170 @@ const gql = {
     }
   `,
 
-  UPDATE_SCHEDULING_CONDITION: `#graphql
-    mutation UpdateSchedulingCondition($id: Int!, $condition: scheduling_condition_set_input!) {
-      updateSchedulingCondition: update_scheduling_condition_by_pk(
-        pk_columns: { id: $id }, _set: $condition
+  UPDATE_SCHEDULING_CONDITION_DEFINITION_TAGS: `#graphql
+    mutation UpdateSchedulingConditionTags($conditionId: Int!, $conditionRevision: Int!, $tags: [scheduling_condition_definition_tags_insert_input!]!, $tagIdsToDelete: [Int!]!) {
+      insertSchedulingConditionDefinitionTags: insert_scheduling_condition_definition_tags(objects: $tags, on_conflict: {
+        constraint: scheduling_condition_definition_tags_pkey,
+        update_columns: []
+      }) {
+        affected_rows
+      }
+      deleteSchedulingConditionDefinitionTags: delete_scheduling_condition_definition_tags(
+        where: {
+          tag_id: { _in: $tagIdsToDelete },
+          _and: {
+            condition_id: { _eq: $conditionId },
+            condition_revision: { _eq: $conditionRevision }
+          }
+        }
+      ) {
+        affected_rows
+      }
+    }
+  `,
+
+  UPDATE_SCHEDULING_CONDITION_METADATA: `#graphql
+    mutation UpdateSchedulingConditionMetadata($id: Int!, $conditionMetadata: scheduling_condition_metadata_set_input!, $tags: [scheduling_condition_tags_insert_input!]!, $tagIdsToDelete: [Int!]!) {
+      updateSchedulingConditionMetadata: update_scheduling_condition_metadata_by_pk(
+        pk_columns: { id: $id }, _set: $conditionMetadata
       ) {
         id
-        last_modified_by
-        modified_date
+      }
+      insertSchedulingConditionTags: insert_scheduling_condition_tags(objects: $tags, on_conflict: {
+        constraint: scheduling_condition_tags_pkey,
+        update_columns: []
+      }) {
+        affected_rows
+      }
+      deleteSchedulingConditionTags: delete_scheduling_condition_tags(where: { tag_id: { _in: $tagIdsToDelete } }) {
+          affected_rows
       }
     }
   `,
 
-  UPDATE_SCHEDULING_GOAL: `#graphql
-    mutation UpdateSchedulingGoal($id: Int!, $goal: scheduling_goal_set_input!) {
-      updateSchedulingGoal: update_scheduling_goal_by_pk(
-        pk_columns: { id: $id }, _set: $goal
+  UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION: `#graphql
+    mutation UpdateSchedulingConditionPlanSpecification($id: Int!, $revision: Int!, $enabled: Boolean!, $specificationId: Int!) {
+      updateSchedulingConditionPlanSpecification: update_scheduling_specification_conditions_by_pk(
+        pk_columns: { condition_id: $id, specification_id: $specificationId },
+        _set: {
+          condition_revision: $revision,
+          enabled: $enabled
+        }
+      ) {
+        condition_revision
+        enabled
+      }
+    }
+  `,
+
+  UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATIONS: `#graphql
+    mutation UpdateSchedulingConditionPlanSpecifications($conditionSpecsToUpdate: [scheduling_specification_conditions_insert_input!]!, $conditionSpecIdsToDelete: [Int!]! = [], $specificationId: Int!) {
+      updateSchedulingConditionPlanSpecifications: insert_scheduling_specification_conditions(
+        objects: $conditionSpecsToUpdate,
+        on_conflict: {
+          constraint: scheduling_specification_conditions_primary_key,
+          update_columns: [condition_revision, enabled]
+        },
+      ) {
+        returning {
+          condition_revision
+          enabled
+        }
+      }
+      deleteSchedulingConditionPlanSpecifications: delete_scheduling_specification_conditions(
+        where: {
+          condition_id: { _in: $conditionSpecIdsToDelete },
+          _and: {
+            specification_id: { _eq: $specificationId },
+          }
+        }
+      ) {
+        affected_rows
+      }
+    }
+  `,
+
+  UPDATE_SCHEDULING_GOAL_DEFINITION_TAGS: `#graphql
+    mutation UpdateSchedulingGoalTags($goalId: Int!, $goalRevision: Int!, $tags: [scheduling_goal_definition_tags_insert_input!]!, $tagIdsToDelete: [Int!]!) {
+      insertSchedulingGoalDefinitionTags: insert_scheduling_goal_definition_tags(objects: $tags, on_conflict: {
+        constraint: scheduling_goal_definition_tags_pkey,
+        update_columns: []
+      }) {
+        affected_rows
+      }
+      deleteSchedulingGoalDefinitionTags: delete_scheduling_goal_definition_tags(
+        where: {
+          tag_id: { _in: $tagIdsToDelete },
+          _and: {
+            goal_id: { _eq: $goalId },
+            goal_revision: { _eq: $goalRevision }
+          }
+        }
+      ) {
+        affected_rows
+      }
+    }
+  `,
+
+  UPDATE_SCHEDULING_GOAL_METADATA: `#graphql
+    mutation UpdateSchedulingGoalMetadata($id: Int!, $goalMetadata: scheduling_goal_metadata_set_input!, $tags: [scheduling_goal_tags_insert_input!]!, $tagIdsToDelete: [Int!]!) {
+      updateSchedulingGoalMetadata: update_scheduling_goal_metadata_by_pk(
+        pk_columns: { id: $id }, _set: $goalMetadata
       ) {
         id
-        last_modified_by
-        modified_date
+      }
+      insertSchedulingGoalTags: insert_scheduling_goal_tags(objects: $tags, on_conflict: {
+        constraint: scheduling_goal_tags_pkey,
+        update_columns: []
+      }) {
+        affected_rows
+      }
+      deleteSchedulingGoalTags: delete_scheduling_goal_tags(where: { tag_id: { _in: $tagIdsToDelete } }) {
+          affected_rows
+      }
+    }
+  `,
+
+  UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATION: `#graphql
+    mutation UpdateSchedulingGoalPlanSpecification($id: Int!, $revision: Int!, $enabled: Boolean!, $priority: Int!, $simulateAfter: Boolean!, $specificationId: Int!) {
+      updateSchedulingGoalPlanSpecification: update_scheduling_specification_goals_by_pk(
+        pk_columns: { goal_id: $id, specification_id: $specificationId },
+        _set: {
+          goal_revision: $revision,
+          enabled: $enabled,
+          priority: $priority,
+          simulate_after: $simulateAfter
+        }
+      ) {
+        goal_revision
+        enabled
+      }
+    }
+  `,
+
+  UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATIONS: `#graphql
+    mutation UpdateSchedulingGoalPlanSpecifications($goalSpecsToUpdate: [scheduling_specification_goals_insert_input!]!, $goalSpecIdsToDelete: [Int!]! = [], $specificationId: Int!) {
+      updateSchedulingGoalPlanSpecifications: insert_scheduling_specification_goals(
+        objects: $goalSpecsToUpdate,
+        on_conflict: {
+          constraint: scheduling_specification_goals_primary_key,
+          update_columns: [goal_revision, enabled]
+        },
+      ) {
+        returning {
+          goal_revision
+          enabled
+        }
+      }
+      deleteSchedulingGoalPlanSpecifications: delete_scheduling_specification_goals(
+        where: {
+          goal_id: { _in: $goalSpecIdsToDelete },
+          _and: {
+            specification_id: { _eq: $specificationId },
+          }
+        }
+      ) {
+        affected_rows
       }
     }
   `,
diff --git a/src/utilities/modal.ts b/src/utilities/modal.ts
index 3f90d70194..0081d0f9d5 100644
--- a/src/utilities/modal.ts
+++ b/src/utilities/modal.ts
@@ -8,6 +8,8 @@ import DeleteActivitiesModal from '../components/modals/DeleteActivitiesModal.sv
 import EditViewModal from '../components/modals/EditViewModal.svelte';
 import ExpansionSequenceModal from '../components/modals/ExpansionSequenceModal.svelte';
 import ManagePlanConstraintsModal from '../components/modals/ManagePlanConstraintsModal.svelte';
+import ManagePlanSchedulingConditionsModal from '../components/modals/ManagePlanSchedulingConditionsModal.svelte';
+import ManagePlanSchedulingGoalsModal from '../components/modals/ManagePlanSchedulingGoalsModal.svelte';
 import MergeReviewEndedModal from '../components/modals/MergeReviewEndedModal.svelte';
 import PlanBranchRequestModal from '../components/modals/PlanBranchRequestModal.svelte';
 import PlanBranchesModal from '../components/modals/PlanBranchesModal.svelte';
@@ -176,6 +178,76 @@ export async function showManagePlanConstraintsModal(user: User | null): Promise
   });
 }
 
+/**
+ * Shows an ManagePlanSchedulingConditionsModal component with the supplied arguments.
+ */
+export async function showManagePlanSchedulingConditionsModal(user: User | null): Promise<ModalElementValue> {
+  return new Promise(resolve => {
+    if (browser) {
+      const target: ModalElement | null = document.querySelector('#svelte-modal');
+
+      if (target) {
+        const managePlanConditionsModal = new ManagePlanSchedulingConditionsModal({
+          props: { user },
+          target,
+        });
+        target.resolve = resolve;
+
+        managePlanConditionsModal.$on('close', () => {
+          target.replaceChildren();
+          target.resolve = null;
+          target.removeAttribute('data-dismissible');
+          managePlanConditionsModal.$destroy();
+        });
+
+        managePlanConditionsModal.$on('add', (e: CustomEvent<{ conditionId: number; conditionRevision: number }[]>) => {
+          target.replaceChildren();
+          target.resolve = null;
+          resolve({ confirm: true, value: e.detail });
+          managePlanConditionsModal.$destroy();
+        });
+      }
+    } else {
+      resolve({ confirm: false });
+    }
+  });
+}
+
+/**
+ * Shows an ManagePlanSchedulingGoalsModal component with the supplied arguments.
+ */
+export async function showManagePlanSchedulingGoalsModal(user: User | null): Promise<ModalElementValue> {
+  return new Promise(resolve => {
+    if (browser) {
+      const target: ModalElement | null = document.querySelector('#svelte-modal');
+
+      if (target) {
+        const managePlanGoalsModal = new ManagePlanSchedulingGoalsModal({
+          props: { user },
+          target,
+        });
+        target.resolve = resolve;
+
+        managePlanGoalsModal.$on('close', () => {
+          target.replaceChildren();
+          target.resolve = null;
+          target.removeAttribute('data-dismissible');
+          managePlanGoalsModal.$destroy();
+        });
+
+        managePlanGoalsModal.$on('add', (e: CustomEvent<{ goalId: number; goalRevision: number }[]>) => {
+          target.replaceChildren();
+          target.resolve = null;
+          resolve({ confirm: true, value: e.detail });
+          managePlanGoalsModal.$destroy();
+        });
+      }
+    } else {
+      resolve({ confirm: false });
+    }
+  });
+}
+
 /**
  * Shows a PlanLockedModal component with the supplied arguments.
  */
diff --git a/src/utilities/permissions.ts b/src/utilities/permissions.ts
index 72d0597853..1152394249 100644
--- a/src/utilities/permissions.ts
+++ b/src/utilities/permissions.ts
@@ -6,7 +6,6 @@ import type { ConstraintMetadata } from '../types/constraint';
 import type { ExpansionRule, ExpansionSequence, ExpansionSet } from '../types/expansion';
 import type { Model } from '../types/model';
 import type {
-  AssetWithAuthor,
   AssetWithOwner,
   CreatePermissionCheck,
   ModelWithOwner,
@@ -16,7 +15,7 @@ import type {
   UpdatePermissionCheck,
 } from '../types/permissions';
 import type { PlanSnapshot } from '../types/plan-snapshot';
-import type { SchedulingCondition, SchedulingGoal } from '../types/scheduling';
+import type { SchedulingConditionMetadata, SchedulingGoalMetadata } from '../types/scheduling';
 import type { UserSequence } from '../types/sequencing';
 import type { Simulation, SimulationTemplate } from '../types/simulation';
 import type { Tag } from '../types/tags';
@@ -45,15 +44,6 @@ function isUserOwner(user: User | null, thingWithOwner?: AssetWithOwner | null):
   return false;
 }
 
-function isUserAuthor(user: User | null, thingWithAuthor?: AssetWithAuthor | null): boolean {
-  if (thingWithAuthor !== null) {
-    if (thingWithAuthor && user) {
-      return thingWithAuthor.author === user.id;
-    }
-  }
-  return false;
-}
-
 function isPlanOwner(user: User | null, plan: AssetWithOwner<PlanWithOwners>): boolean {
   return isUserOwner(user, plan);
 }
@@ -326,18 +316,6 @@ const queryPermissions = {
   CREATE_CONSTRAINT_MODEL_SPECIFICATION: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['insert_constraint_model_specification_one'], user);
   },
-  CREATE_CONSTRAINT_PLAN_SPECIFICATION: (
-    user: User | null,
-    constraint: ConstraintMetadata,
-    plan: PlanWithOwners,
-  ): boolean => {
-    return (
-      isUserAdmin(user) ||
-      (getPermission(['insert_constraint_specification_one'], user) &&
-        (constraint.public || isUserOwner(user, constraint)) &&
-        (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
-    );
-  },
   CREATE_EXPANSION_RULE: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['insert_expansion_rule_one'], user);
   },
@@ -379,32 +357,27 @@ const queryPermissions = {
   CREATE_PLAN_TAGS: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['insert_plan_tags'], user);
   },
-  CREATE_SCHEDULING_CONDITION: (user: User | null, plan: PlanWithOwners): boolean => {
-    return (
-      isUserAdmin(user) ||
-      (getPermission(['insert_scheduling_condition_one'], user) &&
-        (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
-    );
+  CREATE_SCHEDULING_CONDITION: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['insert_scheduling_condition_metadata_one'], user);
   },
-  CREATE_SCHEDULING_GOAL: (user: User | null, plan: PlanWithOwners): boolean => {
-    return (
-      isUserAdmin(user) ||
-      (getPermission(['insert_scheduling_goal_one'], user) &&
-        (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
-    );
+  CREATE_SCHEDULING_CONDITION_DEFINITION: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['insert_scheduling_condition_definition_one'], user);
   },
-  CREATE_SCHEDULING_GOAL_TAGS: (user: User | null): boolean => {
-    return isUserAdmin(user) || getPermission(['insert_scheduling_goal_tags'], user);
+  CREATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['insert_scheduling_specification_conditions_one'], user);
   },
-  CREATE_SCHEDULING_SPEC: (user: User | null): boolean => {
-    return isUserAdmin(user) || getPermission(['insert_scheduling_specification_one'], user);
+  CREATE_SCHEDULING_GOAL: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['insert_scheduling_goal_metadata_one'], user);
   },
-  CREATE_SCHEDULING_SPEC_CONDITION: (user: User | null): boolean => {
-    return isUserAdmin(user) || getPermission(['insert_scheduling_specification_conditions_one'], user);
+  CREATE_SCHEDULING_GOAL_DEFINITION: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['insert_scheduling_goal_definition_one'], user);
   },
-  CREATE_SCHEDULING_SPEC_GOAL: (user: User | null): boolean => {
+  CREATE_SCHEDULING_GOAL_PLAN_SPECIFICATION: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['insert_scheduling_specification_goals_one'], user);
   },
+  CREATE_SCHEDULING_SPEC: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['insert_scheduling_specification_one'], user);
+  },
   CREATE_SIMULATION_TEMPLATE: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['insert_simulation_template_one'], user);
   },
@@ -516,37 +489,35 @@ const queryPermissions = {
         (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
     );
   },
-  DELETE_SCHEDULING_CONDITION: (
+  DELETE_SCHEDULING_CONDITION_METADATA: (
     user: User | null,
-    plan: PlanWithOwners | null,
-    condition?: AssetWithAuthor<SchedulingCondition>,
+    conditionMetadata: AssetWithOwner<SchedulingConditionMetadata>,
   ): boolean => {
     return (
       isUserAdmin(user) ||
-      (getPermission(['delete_scheduling_condition_by_pk'], user) &&
-        // If there is a plan, ensure user is the plan owner or is a collaborator
-        // Otherwise if no plan, user may delete if they are goal author since associated plan may have been deleted
-        (plan ? isPlanOwner(user, plan) || isPlanCollaborator(user, plan) : isUserAuthor(user, condition)))
+      (getPermission(['delete_scheduling_condition_metadata_by_pk'], user) && isUserOwner(user, conditionMetadata))
     );
   },
-  DELETE_SCHEDULING_GOAL: (
+  DELETE_SCHEDULING_CONDITION_METADATA_TAGS: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['delete_scheduling_condition_metadata_tags'], user);
+  },
+  DELETE_SCHEDULING_CONDITION_PLAN_SPECIFICATION: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['delete_scheduling_specification_conditions'], user);
+  },
+  DELETE_SCHEDULING_GOAL_METADATA: (
     user: User | null,
-    plan: PlanWithOwners | null,
-    goal?: AssetWithAuthor<SchedulingGoal>,
+    goalMetadata: AssetWithOwner<SchedulingGoalMetadata>,
   ): boolean => {
     return (
       isUserAdmin(user) ||
-      (getPermission(['delete_scheduling_goal_by_pk'], user) &&
-        // If there is a plan, ensure user is the plan owner or is a collaborator
-        // Otherwise if no plan, user may delete if they are goal author since associated plan may have been deleted
-        (plan ? isPlanOwner(user, plan) || isPlanCollaborator(user, plan) : isUserAuthor(user, goal)))
+      (getPermission(['delete_scheduling_goal_metadata_by_pk'], user) && isUserOwner(user, goalMetadata))
     );
   },
-  DELETE_SCHEDULING_GOAL_TAGS: (user: User | null): boolean => {
-    return isUserAdmin(user) || getPermission(['delete_scheduling_goal_tags'], user);
+  DELETE_SCHEDULING_GOAL_METADATA_TAGS: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['delete_scheduling_goal_metadata_tags'], user);
   },
-  DELETE_SCHEDULING_SPEC_GOAL: (user: User | null): boolean => {
-    return isUserAdmin(user) || getPermission(['delete_scheduling_specification_goals_by_pk'], user);
+  DELETE_SCHEDULING_GOAL_PLAN_SPECIFICATION: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['delete_scheduling_specification_goal'], user);
   },
   DELETE_SIMULATION_TEMPLATE: (user: User | null, template: SimulationTemplate): boolean => {
     return (
@@ -712,6 +683,15 @@ const queryPermissions = {
   SUB_PLAN_SNAPSHOTS: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['plan_snapshot'], user);
   },
+  SUB_SCHEDULING_CONDITIONS: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['scheduling_condition_metadata'], user);
+  },
+  SUB_SCHEDULING_GOALS: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['scheduling_goal_metadata'], user);
+  },
+  SUB_SCHEDULING_PLAN_SPECIFICATION: (user: User | null): boolean => {
+    return isUserAdmin(user) || getPermission(['scheduling_specification'], user);
+  },
   SUB_SIMULATION: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['simulation'], user);
   },
@@ -768,41 +748,89 @@ const queryPermissions = {
   UPDATE_PLAN_SNAPSHOT: (user: User | null): boolean => {
     return getPermission(['update_plan_snapshot_by_pk'], user);
   },
-  UPDATE_SCHEDULING_CONDITION: (
+  UPDATE_SCHEDULING_CONDITION_DEFINITION_TAGS: (user: User | null): boolean => {
+    return (
+      isUserAdmin(user) ||
+      getPermission(
+        ['insert_scheduling_condition_definition_tags', 'delete_scheduling_condition_definition_tags'],
+        user,
+      )
+    );
+  },
+  UPDATE_SCHEDULING_CONDITION_METADATA: (
     user: User | null,
-    plan: PlanWithOwners | null,
-    condition?: AssetWithAuthor<SchedulingCondition>,
+    condition?: AssetWithOwner<SchedulingConditionMetadata>,
   ): boolean => {
     return (
       isUserAdmin(user) ||
-      (getPermission(['update_scheduling_condition_by_pk'], user) &&
+      (getPermission(
+        [
+          'update_scheduling_condition_metadata_by_pk',
+          'insert_scheduling_condition_tags',
+          'delete_scheduling_condition_tags',
+        ],
+        user,
+      ) &&
         // If there is a plan, ensure user is the plan owner or is a collaborator
         // Otherwise if no plan, user may update if they are condition author since associated plan may have been deleted
-        (plan ? isPlanOwner(user, plan) || isPlanCollaborator(user, plan) : isUserAuthor(user, condition)))
+        (condition?.public || isUserOwner(user, condition)))
     );
   },
-  UPDATE_SCHEDULING_GOAL: (
-    user: User | null,
-    plan: PlanWithOwners | null,
-    goal?: AssetWithAuthor<SchedulingGoal>,
-  ): boolean => {
+  UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION: (user: User | null, plan: PlanWithOwners): boolean => {
+    return (
+      isUserAdmin(user) ||
+      (getPermission(['update_scheduling_specification_conditions_by_pk'], user) &&
+        (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
+    );
+  },
+  UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATIONS: (user: User | null, plan: PlanWithOwners): boolean => {
+    return (
+      isUserAdmin(user) ||
+      (getPermission(
+        ['insert_scheduling_specification_conditions', 'delete_scheduling_specification_conditions'],
+        user,
+      ) &&
+        (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
+    );
+  },
+  UPDATE_SCHEDULING_GOAL_DEFINITION_TAGS: (user: User | null): boolean => {
+    return (
+      isUserAdmin(user) ||
+      getPermission(['insert_scheduling_goal_definition_tags', 'delete_scheduling_goal_definition_tags'], user)
+    );
+  },
+  UPDATE_SCHEDULING_GOAL_METADATA: (user: User | null, goal?: AssetWithOwner<SchedulingGoalMetadata>): boolean => {
     return (
       isUserAdmin(user) ||
-      (getPermission(['update_scheduling_goal_by_pk'], user) &&
+      (getPermission(
+        ['update_scheduling_goal_metadata_by_pk', 'insert_scheduling_goal_tags', 'delete_scheduling_goal_tags'],
+        user,
+      ) &&
         // If there is a plan, ensure user is the plan owner or is a collaborator
         // Otherwise if no plan, user may update if they are goal author since associated plan may have been deleted
-        (plan ? isPlanOwner(user, plan) || isPlanCollaborator(user, plan) : isUserAuthor(user, goal)))
+        (goal?.public || isUserOwner(user, goal)))
     );
   },
-  UPDATE_SCHEDULING_SPEC: (user: User | null, plan: PlanWithOwners): boolean => {
+  UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATION: (user: User | null, plan: PlanWithOwners): boolean => {
     return (
       isUserAdmin(user) ||
-      (getPermission(['update_scheduling_specification_by_pk'], user) &&
+      (getPermission(['update_scheduling_specification_goals_by_pk'], user) &&
         (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
     );
   },
-  UPDATE_SCHEDULING_SPEC_CONDITION: (user: User | null): boolean => {
-    return isUserAdmin(user) || getPermission(['update_scheduling_specification_conditions_by_pk'], user);
+  UPDATE_SCHEDULING_GOAL_PLAN_SPECIFICATIONS: (user: User | null, plan: PlanWithOwners): boolean => {
+    return (
+      isUserAdmin(user) ||
+      (getPermission(['insert_scheduling_specification_goals', 'delete_scheduling_specification_goals'], user) &&
+        (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
+    );
+  },
+  UPDATE_SCHEDULING_PLAN_SPECIFICATIONS: (user: User | null, plan: PlanWithOwners): boolean => {
+    return (
+      isUserAdmin(user) ||
+      (getPermission(['update_scheduling_specification_by_pk'], user) &&
+        (isPlanOwner(user, plan) || isPlanCollaborator(user, plan)))
+    );
   },
   UPDATE_SCHEDULING_SPEC_CONDITION_ID: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission(['update_scheduling_specification_conditions_by_pk'], user);
@@ -887,6 +915,13 @@ interface PlanAssetCRUDPermission<T = null> {
   canUpdate: PlanAssetUpdatePermissionCheck<T>;
 }
 
+interface PlanSpecificationCRUDPermission<T = null> {
+  canCreate: PlanAssetCreatePermissionCheck;
+  canDelete: (user: User | null, asset: T) => boolean;
+  canRead: ReadPermissionCheck<T>;
+  canUpdate: (user: User | null, plan: PlanWithOwners) => boolean;
+}
+
 interface PlanActivityPresetsCRUDPermission
   extends Omit<PlanAssetCRUDPermission<ActivityPreset>, 'canDelete' | 'canUpdate'> {
   canAssign: RolePlanPermissionCheckWithAsset<ActivityPreset>;
@@ -903,6 +938,9 @@ interface PlanSimulationTemplateCRUDPermission extends Omit<PlanAssetCRUDPermiss
 interface RunnableCRUDPermission<T = null> extends PlanAssetCRUDPermission<T> {
   canRun: (user: User | null, plan: PlanWithOwners, model: ModelWithOwner) => boolean;
 }
+interface RunnableSpecificationCRUDPermission<T = null> extends PlanSpecificationCRUDPermission<T> {
+  canRun: (user: User | null, plan: PlanWithOwners, model: ModelWithOwner) => boolean;
+}
 
 interface PlanSnapshotCRUDPermission extends Omit<PlanAssetCRUDPermission<PlanSnapshot>, 'canCreate' | 'canDelete'> {
   canCreate: RolePlanPermissionCheck;
@@ -927,18 +965,11 @@ interface ExpansionSequenceCRUDPermission<T = null> extends CRUDPermission<T> {
   canExpand: RolePlanPermissionCheck;
 }
 
-interface SchedulingCRUDPermission<T = null> extends RunnableCRUDPermission<T> {
+interface SchedulingCRUDPermission<T = null> extends RunnableSpecificationCRUDPermission<T> {
   canAnalyze: (user: User | null, plan: PlanWithOwners, model: ModelWithOwner) => boolean;
-  canDelete: (user: User | null, plan: PlanWithOwners | null, asset?: T) => boolean;
-  canUpdate: (user: User | null, plan: PlanWithOwners | null, asset?: T) => boolean;
   canUpdateSpecification: (user: User | null, plan: PlanWithOwners) => boolean;
 }
 
-interface ConditionsCRUDPermission<T = null> extends PlanAssetCRUDPermission<T> {
-  canDelete: (user: User | null, plan: PlanWithOwners | null, asset?: T) => boolean;
-  canUpdate: (user: User | null, plan: PlanWithOwners | null, asset?: T) => boolean;
-}
-
 interface FeaturePermissions {
   activityDirective: PlanAssetCRUDPermission<ActivityDirective>;
   activityPresets: PlanActivityPresetsCRUDPermission;
@@ -952,8 +983,10 @@ interface FeaturePermissions {
   plan: CRUDPermission<PlanWithOwners>;
   planBranch: PlanBranchCRUDPermission;
   planSnapshot: PlanSnapshotCRUDPermission;
-  schedulingConditions: ConditionsCRUDPermission<AssetWithAuthor<SchedulingCondition>>;
-  schedulingGoals: SchedulingCRUDPermission<AssetWithAuthor<SchedulingGoal>>;
+  schedulingConditions: CRUDPermission<AssetWithOwner<SchedulingConditionMetadata>>;
+  schedulingConditionsPlanSpec: PlanSpecificationCRUDPermission<AssetWithOwner<SchedulingConditionMetadata>>;
+  schedulingGoals: CRUDPermission<AssetWithOwner<SchedulingGoalMetadata>>;
+  schedulingGoalsPlanSpec: SchedulingCRUDPermission<AssetWithOwner<SchedulingGoalMetadata>>;
   sequences: CRUDPermission<AssetWithOwner<UserSequence>>;
   simulation: RunnableCRUDPermission<AssetWithOwner<Simulation>>;
   simulationTemplates: PlanSimulationTemplateCRUDPermission;
@@ -1049,20 +1082,34 @@ const featurePermissions: FeaturePermissions = {
     canUpdate: () => false, // no feature to update snapshots exists,
   },
   schedulingConditions: {
-    canCreate: (user, plan) => queryPermissions.CREATE_SCHEDULING_CONDITION(user, plan),
-    canDelete: (user, plan, condition) => queryPermissions.DELETE_SCHEDULING_CONDITION(user, plan, condition),
+    canCreate: user => queryPermissions.CREATE_SCHEDULING_CONDITION(user),
+    canDelete: (user, condition) => queryPermissions.DELETE_SCHEDULING_CONDITION_METADATA(user, condition),
+    canRead: user => queryPermissions.SUB_SCHEDULING_CONDITIONS(user),
+    canUpdate: (user, condition) => queryPermissions.UPDATE_SCHEDULING_CONDITION_METADATA(user, condition),
+  },
+  schedulingConditionsPlanSpec: {
+    canCreate: user => queryPermissions.CREATE_SCHEDULING_CONDITION_PLAN_SPECIFICATION(user),
+    canDelete: user => queryPermissions.DELETE_SCHEDULING_CONDITION_PLAN_SPECIFICATION(user),
     canRead: () => false,
-    canUpdate: (user, plan, condition) => queryPermissions.UPDATE_SCHEDULING_CONDITION(user, plan, condition),
+    canUpdate: (user, plan) => queryPermissions.UPDATE_SCHEDULING_CONDITION_PLAN_SPECIFICATIONS(user, plan),
   },
   schedulingGoals: {
+    canCreate: user => queryPermissions.CREATE_SCHEDULING_GOAL(user),
+    canDelete: (user, goal) => queryPermissions.DELETE_SCHEDULING_GOAL_METADATA(user, goal),
+    canRead: user => queryPermissions.SUB_SCHEDULING_GOALS(user),
+    canUpdate: (user, goal) => queryPermissions.UPDATE_SCHEDULING_GOAL_METADATA(user, goal),
+  },
+  schedulingGoalsPlanSpec: {
     canAnalyze: (user, plan, model) =>
-      queryPermissions.UPDATE_SCHEDULING_SPEC(user, plan) && queryPermissions.SCHEDULE(user, plan, model),
-    canCreate: (user, plan) => queryPermissions.CREATE_SCHEDULING_GOAL(user, plan),
-    canDelete: (user, plan, goal) => queryPermissions.DELETE_SCHEDULING_GOAL(user, plan, goal),
+      queryPermissions.UPDATE_SCHEDULING_PLAN_SPECIFICATIONS(user, plan) &&
+      queryPermissions.SCHEDULE(user, plan, model),
+    canCreate: user => queryPermissions.CREATE_SCHEDULING_GOAL(user),
+    canDelete: (user, goal) => queryPermissions.DELETE_SCHEDULING_GOAL_METADATA(user, goal),
     canRead: () => false,
     canRun: (user, plan, model) =>
-      queryPermissions.UPDATE_SCHEDULING_SPEC(user, plan) && queryPermissions.SCHEDULE(user, plan, model),
-    canUpdate: (user, plan, goal) => queryPermissions.UPDATE_SCHEDULING_GOAL(user, plan, goal),
+      queryPermissions.UPDATE_SCHEDULING_PLAN_SPECIFICATIONS(user, plan) &&
+      queryPermissions.SCHEDULE(user, plan, model),
+    canUpdate: (user, goal) => queryPermissions.UPDATE_SCHEDULING_GOAL_METADATA(user, goal),
     canUpdateSpecification: (user, plan) => queryPermissions.UPDATE_SCHEDULING_SPEC_GOAL(user, plan),
   },
   sequences: {
diff --git a/src/utilities/scheduling.ts b/src/utilities/scheduling.ts
new file mode 100644
index 0000000000..8b6295a300
--- /dev/null
+++ b/src/utilities/scheduling.ts
@@ -0,0 +1,45 @@
+import type { BaseDefinition, BaseMetadata } from '../types/metadata';
+import type { Plan } from '../types/plan';
+import type { SchedulingMetadataResponse } from '../types/scheduling';
+import type { Tag } from '../types/tags';
+
+export function convertResponseToMetadata<M, D>(schedulingResponse: SchedulingMetadataResponse<M, D>, tags: Tag[]): M {
+  const schedulingMetadata: M = {
+    ...schedulingResponse,
+    ...(schedulingResponse.plans_using
+      ? ({
+          plans_using: schedulingResponse.plans_using.reduce((plansUsing: Pick<Plan, 'id'>[], planUsing) => {
+            if (planUsing.specification) {
+              return [
+                ...plansUsing,
+                {
+                  id: planUsing.specification.plan_id,
+                },
+              ];
+            }
+
+            return plansUsing;
+          }, []),
+        } as Pick<BaseMetadata<BaseDefinition>, 'plans_using'>)
+      : { plans_using: [] }),
+    tags: schedulingResponse.tags.reduce((finalTags: { tag: Tag }[], { tag_id }) => {
+      const tag = tags.find(tag => tag.id === tag_id);
+      if (tag) {
+        return [...finalTags, { tag }];
+      }
+      return finalTags;
+    }, []),
+    versions: schedulingResponse.versions.map(schedulingRevision => ({
+      ...schedulingRevision,
+      tags: schedulingRevision.tags.reduce((finalTags: { tag: Tag }[], { tag_id }) => {
+        const tag = tags.find(tag => tag.id === tag_id);
+        if (tag) {
+          return [...finalTags, { tag }];
+        }
+        return finalTags;
+      }, []),
+    })),
+  } as M;
+
+  return schedulingMetadata;
+}