diff --git a/.agent/knowledge/api-cheatsheet.md b/.agent/knowledge/api-cheatsheet.md
new file mode 100644
index 0000000000..2336cd30aa
--- /dev/null
+++ b/.agent/knowledge/api-cheatsheet.md
@@ -0,0 +1,81 @@
+# `openmct.*` Cheat Sheet
+
+## Bootstrapping
+
+```js
+openmct.install(plugin);
+openmct.start(elOrSelector);
+```
+
+## Types
+
+```js
+openmct.types.addType(key, {
+  name, description, cssClass, creatable, initialize
+});
+openmct.types.get(key);
+```
+
+## Objects
+
+```js
+openmct.objects.addRoot(idOrFn, priority);
+openmct.objects.addProvider(namespace, { get(identifier) });
+openmct.objects.get(identifier);
+openmct.objects.mutate(obj, path, value);
+```
+
+## Composition
+
+```js
+openmct.composition.addProvider({ appliesTo(obj), load(obj) });
+openmct.composition.get(obj); // returns CompositionCollection
+```
+
+## Telemetry
+
+```js
+openmct.telemetry.addProvider({
+  supportsRequest(o, opts), request(o, opts),
+  supportsSubscribe(o),     subscribe(o, cb, opts),
+  supportsMetadata(o),      getMetadata(o),
+  supportsLimits(o),        getLimitEvaluator(o)
+});
+openmct.telemetry.addFormat({ key, format, parse, validate });
+openmct.telemetry.request(obj, opts);
+openmct.telemetry.subscribe(obj, cb, opts);
+```
+
+## Time
+
+```js
+openmct.time.addTimeSystem(sys);
+openmct.time.setTimeSystem(key, bounds);
+openmct.time.getTimeSystem();
+
+openmct.time.addClock(clk);
+openmct.time.setClock(clk, offsets);
+openmct.time.getClock();
+
+openmct.time.setBounds(b);        openmct.time.getBounds();
+openmct.time.setClockOffsets(o);  openmct.time.getClockOffsets();
+openmct.time.setMode('realtime' | 'fixed');
+openmct.time.getMode();
+openmct.time.isRealTime();
+openmct.time.isFixed();
+```
+
+Events: `boundsChanged`, `timeSystemChanged`, `clockChanged`,
+`clockOffsetsChanged`, `modeChanged`.
+
+## Indicators
+
+```js
+const ind = openmct.indicators.simpleIndicator();
+ind.text('…').iconClass('icon-info');
+openmct.indicators.add(ind); // or add({ element })
+```
+
+## Priority
+
+`openmct.priority.HIGHEST | HIGH | DEFAULT | LOW | LOWEST`
diff --git a/.agent/knowledge/architecture.md b/.agent/knowledge/architecture.md
new file mode 100644
index 0000000000..2ef2bffaf4
--- /dev/null
+++ b/.agent/knowledge/architecture.md
@@ -0,0 +1,32 @@
+# Architecture — Mental Model
+
+Open MCT is a **framework core** + **plugin registry**.
+
+Core (`src/MCT.js` → `src/api/*`) owns:
+
+- object registry & providers
+- composition graph
+- telemetry pipeline
+- time system + clocks
+- view / action / indicator / form / menu / notification registries
+- priority scheme
+
+Plugins add:
+
+- types (kinds of objects)
+- object providers (how to fetch models by identifier)
+- composition providers (what children an object has)
+- telemetry providers (historical + realtime data)
+- view providers (how to render an object)
+- action providers (context-menu / toolbar operations)
+- indicators, formatters, time systems, clocks
+
+Data flow for a plot:
+
+1. Time bounds change → view calls `openmct.telemetry.request(obj, opts)`.
+2. Matching provider returns `Datum[]` → view renders history.
+3. Provider is also subscribed → new datums pushed → view appends live.
+
+Domain-object identity:
+`{ namespace, key }` — namespace usually maps 1:1 to a persistence store
+or a plugin's synthetic root.
diff --git a/.agent/knowledge/glossary.md b/.agent/knowledge/glossary.md
new file mode 100644
index 0000000000..ea99f6e318
--- /dev/null
+++ b/.agent/knowledge/glossary.md
@@ -0,0 +1,18 @@
+# Glossary
+
+- **domain object** — anything shown in the tree; `{ namespace, key }` identity.
+- **model** — JSON-serializable state of a domain object.
+- **composition** — array of child identifiers.
+- **namespace** — persistence / provider partition.
+- **type** — registered kind of domain object.
+- **provider** — plugin implementation of an extension point.
+- **datum** — one telemetry sample; a plain JS object keyed by value-metadata
+  keys.
+- **time system** — defines how numeric time values are interpreted and
+  formatted.
+- **clock** — ticking source of "now" values in a time system.
+- **bounds** — `{ start, end }` window in the active time system.
+- **offsets** — relative `{ start<0, end>=0 }` used with clocks in realtime
+  mode.
+- **view provider** — object with `{ key, canView, view(o, path) }`.
+- **action provider** — context-menu / toolbar operation registration.
diff --git a/.agent/knowledge/plugin-anatomy.md b/.agent/knowledge/plugin-anatomy.md
new file mode 100644
index 0000000000..fd24392023
--- /dev/null
+++ b/.agent/knowledge/plugin-anatomy.md
@@ -0,0 +1,40 @@
+# Plugin Anatomy
+
+## Minimum
+
+```js
+export default function MyPlugin(options) {
+  return function install(openmct) {
+    /* register types, providers, views, actions */
+  };
+}
+```
+
+## Recommended layout (feature-first)
+
+```txt
+src/plugins/myPlugin/
+  plugin.js
+  pluginSpec.js
+  README.md
+  MyProvider.js
+  MyProviderSpec.js
+  components/
+    MyView.vue
+  myPlugin.scss
+```
+
+## Registration
+
+In `src/plugins/plugins.js`:
+
+```js
+import MyPlugin from './myPlugin/plugin.js';
+plugins.MyPlugin = MyPlugin;
+```
+
+## Install (host page or test)
+
+```js
+openmct.install(openmct.plugins.MyPlugin(optionalConfig));
+```
diff --git a/.agent/knowledge/reference-plugins.md b/.agent/knowledge/reference-plugins.md
new file mode 100644
index 0000000000..523f762106
--- /dev/null
+++ b/.agent/knowledge/reference-plugins.md
@@ -0,0 +1,15 @@
+# Reference Plugins (Guided Tours)
+
+- `src/plugins/conjunctionSSA/` — full example: types, root, object provider,
+  composition tree, telemetry (subscribe + request), condition set, layout.
+  Read its `README.md` for the walkthrough.
+- `src/plugins/telemetryTable/` — view-heavy plugin backed by a telemetry
+  source. Good template for tabular views.
+- `src/plugins/gauge/` — smaller view provider example with a composition
+  policy and a substantial spec file (`GaugePluginSpec.js`).
+- `src/plugins/plot/` — largest view plugin; look here for time-series
+  rendering patterns and `minmax` strategy handling.
+- `src/plugins/condition/` — rule-engine style; useful for derived state.
+- `src/plugins/utcTimeSystem/` — the canonical time-system + clock plugin.
+- `example/generator/` — synthetic telemetry source; ideal for scaffolding
+  new telemetry providers.
diff --git a/.agent/knowledge/telemetry-datum-shapes.md b/.agent/knowledge/telemetry-datum-shapes.md
new file mode 100644
index 0000000000..5790e17697
--- /dev/null
+++ b/.agent/knowledge/telemetry-datum-shapes.md
@@ -0,0 +1,43 @@
+# Telemetry Metadata & Datums
+
+## Telemetry object
+
+```js
+{
+  identifier: { namespace, key },
+  name,
+  type,
+  telemetry: {
+    values: [
+      { key: 'utc', source: 'timestamp', format: 'utc', hints: { domain: 1 } },
+      {
+        key: 'value',
+        name: 'Value',
+        unit: 'kg',
+        format: 'float',
+        min: 0,
+        max: 100,
+        hints: { range: 1 }
+      }
+    ]
+  }
+}
+```
+
+## Datum shape
+
+Keys match `telemetry.values[].source` (or `key` if no `source`):
+
+```js
+{ timestamp: 1712345678000, value: 42 }
+```
+
+## Rules
+
+- Exactly one value MUST have `hints.domain` and must correspond to the active
+  time system's key (map with `source` if the raw field name differs).
+- `request()` returns `Promise<Datum[]>`, sorted ascending by domain.
+- `subscribe()` returns an unsubscribe function; each callback receives
+  exactly one datum.
+- For enums: `format: 'enum'` + `enumerations: [{ value, string }]`.
+- For arrays: `format: 'number[]'` or `format: 'string[]'`.
diff --git a/.agent/knowledge/time-api.md b/.agent/knowledge/time-api.md
new file mode 100644
index 0000000000..f94578567c
--- /dev/null
+++ b/.agent/knowledge/time-api.md
@@ -0,0 +1,41 @@
+# Time API Notes
+
+Modes: `'realtime'` | `'fixed'`.
+
+- Realtime uses a clock + offsets.
+- Fixed uses absolute bounds.
+
+Offsets: `{ start: <negative>, end: >= 0 }` — relative to
+`clock.currentValue()`.
+
+## Custom clock
+
+```js
+{
+  key, name, cssClass, description,
+  on(event, cb),   // event === 'tick'
+  off(event, cb),
+  currentValue()
+}
+```
+
+Register: `openmct.time.addClock(clk)`.
+
+## Custom time system
+
+```js
+{
+  key,
+  name,
+  cssClass,
+  timeFormat,      // key of a registered format
+  durationFormat,  // key of a registered format
+  isUTCBased
+}
+```
+
+## Deprecated — do not use in new code
+
+- Methods: `timeSystem()`, `bounds()`, `clock()`, `clockOffsets()`,
+  `stopClock()`
+- Events: `'bounds'`, `'timeSystem'`, `'clock'`, `'clockOffsets'`
diff --git a/.cspell.json b/.cspell.json
index f8710f7fc7..efadfa2c29 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -2,6 +2,19 @@
   "version": "0.2",
   "language": "en,en-us",
   "words": [
+    "alfano",
+    "envisat",
+    "gmst",
+    "keplerian",
+    "luni",
+    "myorg",
+    "perifocal",
+    "raan",
+    "starlink",
+    "tesserals",
+    "tles",
+    "zarya",
+    "zonals",
     "gress",
     "doctoc",
     "minmax",
diff --git a/.devin/rules/00-project-overview.md b/.devin/rules/00-project-overview.md
new file mode 100644
index 0000000000..dd82cb1b10
--- /dev/null
+++ b/.devin/rules/00-project-overview.md
@@ -0,0 +1,22 @@
+---
+trigger: always_on
+---
+
+# Open MCT — Project Overview
+
+- Framework for time-series / telemetry dashboards. Entry: `openmct.js` → `src/MCT.js`.
+- Composed of ~66 built-in plugins under `src/plugins/`, aggregated in `src/plugins/plugins.js`.
+- Extension points live in `src/api/` (objects, composition, telemetry, time,
+  types, actions, forms, indicators, priority, user, menu, notifications,
+  tooltips, overlays, annotation, status).
+- Demo host: `index.html` (served by `npm start`).
+- Build: webpack configs in `.webpack/`. Types generated by `tsc` from JSDoc.
+- Unit tests: Karma + Jasmine, `*Spec.js` colocated. E2E: Playwright under `e2e/`.
+
+Vocabulary (see `.agent/knowledge/glossary.md`):
+
+- **Domain object**: any item in the tree. Identified by `{namespace, key}`.
+- **Model**: JSON-serializable state of a domain object.
+- **Composition**: parent→children relation.
+- **Type**: registered kind of domain object.
+- **Provider**: plugin-supplied implementation (object/composition/telemetry/etc.).
diff --git a/.devin/rules/10-code-style.md b/.devin/rules/10-code-style.md
new file mode 100644
index 0000000000..b4e070dd34
--- /dev/null
+++ b/.devin/rules/10-code-style.md
@@ -0,0 +1,38 @@
+---
+trigger: always_on
+---
+
+# Code Style (enforced by ESLint + Prettier)
+
+Formatting (Prettier config: `.prettierrc`):
+
+- Single quotes, no trailing commas, `printWidth: 100`, `endOfLine: auto`.
+
+Language:
+
+- ES modules only. `import` at top of file. No `require` in `src/`.
+- `const`/`let` only, never `var`. Prefer `const`.
+- `===` / `!==` only. `curly` always. No nested ternaries. No bitwise ops.
+- Prefer named function declarations over arrow-assigned functions
+  (`func-style: declaration`).
+- One class per file (`max-classes-per-file: 1`).
+- Prefer ES6 classes over prototypal patterns.
+- Avoid magic numbers — hoist to named `const`s in `UPPER_SNAKE_CASE`.
+- No lodash/underscore where a builtin exists (plugin
+  `you-dont-need-lodash-underscore`).
+- No unsanitized DOM writes (`no-unsanitized/DOM`).
+- Imports must be sortable (`simple-import-sort/imports`).
+
+Filenames (`unicorn/filename-case`):
+
+- JS: camelCase for utility modules; PascalCase for files exporting a class or
+  Vue component.
+- `.vue` and files exporting classes → PascalCase (`MyThing.vue`, `MyThing.js`).
+
+Organization: **by feature, not by type** (see CONTRIBUTING.md example).
+
+Do NOT:
+
+- Add or remove comments/JSDoc unless asked.
+- Modify eslint/prettier config to make code pass.
+- Introduce Angular, RxJS, or other frameworks. Vue 3 only.
diff --git a/.devin/rules/20-plugin-authoring.md b/.devin/rules/20-plugin-authoring.md
new file mode 100644
index 0000000000..c184d7a450
--- /dev/null
+++ b/.devin/rules/20-plugin-authoring.md
@@ -0,0 +1,47 @@
+---
+trigger: glob
+globs: src/plugins/**
+---
+
+# Plugin Authoring Rules
+
+A plugin is a factory returning an install function:
+
+```js
+export default function MyPlugin(options) {
+  return function install(openmct) {
+    // register types, providers, views, actions...
+  };
+}
+```
+
+Structure:
+
+- Folder per plugin: `src/plugins/<pluginName>/`.
+- Entry: `plugin.js` exporting `default` factory.
+- Register in `src/plugins/plugins.js` as `plugins.MyPlugin = MyPlugin;`.
+- Colocate `pluginSpec.js` at the plugin root. Split when it grows too large.
+- Vue SFCs in `components/` subfolder; PascalCase filenames.
+- SCSS colocated (e.g. `myPlugin.scss`), imported from JS where needed.
+
+Namespaces & identifiers:
+
+- Always namespace your type keys (e.g. `myorg.thing`) to avoid collisions.
+- Object identifiers are `{ namespace, key }`; keys are unique within a namespace.
+
+Providers to know:
+
+- `openmct.types.addType(key, def)`
+- `openmct.objects.addRoot(idOrFn, priority)` +
+  `openmct.objects.addProvider(namespace, { get })`
+- `openmct.composition.addProvider({ appliesTo, load })`
+- `openmct.telemetry.addProvider({ supportsRequest, request, supportsSubscribe, subscribe, ... })`
+- `openmct.time.addTimeSystem(...)`, `openmct.time.addClock(...)`
+- `openmct.indicators.add(...)`, `openmct.priority.HIGH|LOW|...`
+
+Reference plugins:
+
+- `src/plugins/conjunctionSSA/` — full end-to-end example (types, root,
+  object provider, composition, telemetry, condition set, layout).
+- `src/plugins/telemetryTable/` — view-heavy plugin backed by a telemetry source.
+- `src/plugins/gauge/` — smaller view provider with composition policy.
diff --git a/.devin/rules/21-api-usage.md b/.devin/rules/21-api-usage.md
new file mode 100644
index 0000000000..f4ce31331d
--- /dev/null
+++ b/.devin/rules/21-api-usage.md
@@ -0,0 +1,22 @@
+---
+trigger: glob
+globs: src/**/*.js,src/**/*.vue
+---
+
+# Open MCT API Usage
+
+- Access APIs through the `openmct` instance passed to plugin installers or via
+  the framework — do NOT import from `src/api/*` directly in plugin code.
+- Telemetry datums must include a value keyed to the active time system's `key`
+  (default `utc`). Metadata declares this via `telemetry.values[].hints.domain`.
+- Telemetry providers must return arrays sorted ascending by domain from
+  `request()`, and must return an unsubscribe function from `subscribe()`.
+- View providers should use the `renderWhenVisible(fn)` helper from
+  `viewOptions` instead of raw `requestAnimationFrame` (see `API.md`).
+- Prefer `openmct.priority.*` constants over raw numeric priorities.
+- Time API: use `getTimeSystem`/`setTimeSystem`, `getBounds`/`setBounds`,
+  `getClock`/`setClock`, `getMode`/`setMode`. Deprecated single-name methods
+  (`timeSystem()`, `bounds()`, `clock()`, `clockOffsets()`, `stopClock()`)
+  must not be used in new code.
+- Events: `boundsChanged`, `timeSystemChanged`, `clockChanged`,
+  `clockOffsetsChanged`, `modeChanged` — the un-suffixed versions are deprecated.
diff --git a/.devin/rules/30-testing-unit.md b/.devin/rules/30-testing-unit.md
new file mode 100644
index 0000000000..646da72ca8
--- /dev/null
+++ b/.devin/rules/30-testing-unit.md
@@ -0,0 +1,22 @@
+---
+trigger: glob
+globs: **/*Spec.js
+---
+
+# Unit Testing (Karma + Jasmine)
+
+- Colocate `FooSpec.js` next to `Foo.js`. For plugins, start with
+  `pluginSpec.js` at the plugin root; split as it grows.
+- Prefer public API + browser builtins. Do NOT reach into private modules.
+- Install the plugin under test in `beforeEach` via `createOpenMct()` from
+  `src/utils/testing.js`. Tear down with `resetApplicationState(openmct)` in
+  `afterEach`.
+- Declare state inside block scope; initialize in `beforeEach` (not
+  `beforeAll`) to avoid state leakage between tests.
+- Use `spyOnBuiltins` + `clearBuiltinSpies` (called via
+  `resetApplicationState`) when wrapping `window`/globals.
+- Use `getMockObjects`, `getMockTelemetry`, `getLatestTelemetry` helpers where
+  they fit — extend `setMockObjects()` for new mock shapes.
+- Test the plugin's public effects (types added, objects available, telemetry
+  callbacks invoked) — not internal implementation details.
+- Run: `npm test`. Debug: `npm run test:debug`.
diff --git a/.devin/rules/31-testing-e2e.md b/.devin/rules/31-testing-e2e.md
new file mode 100644
index 0000000000..5e324c425e
--- /dev/null
+++ b/.devin/rules/31-testing-e2e.md
@@ -0,0 +1,19 @@
+---
+trigger: glob
+globs: e2e/**/*.js
+---
+
+# E2E Testing (Playwright)
+
+- Tests live under `e2e/tests/{functional,visual-a11y,performance,mobile}`.
+- Filename pattern: `*.e2e.spec.js`.
+- Use existing fixtures from `e2e/baseFixtures.js` and helpers in `e2e/helper/`.
+- Tag tests: `@a11y`, `@snapshot`, `@couchdb`, `@generatedata`, `@mobile` — CI
+  filters on these tags.
+- Do NOT interleave visual and functional assertions in the same spec (visual
+  goes through Percy and won't run everywhere).
+- For local iteration: `npm run test:e2e:local -- <grep> --debug`.
+- CI parity: `npm run test:e2e:ci`.
+- Prefer role/label locators over CSS selectors.
+- Do not add arbitrary `waitForTimeout`. Prefer `expect(...).toBeVisible()` or
+  `waitFor` on observable state.
diff --git a/.devin/rules/40-vue-components.md b/.devin/rules/40-vue-components.md
new file mode 100644
index 0000000000..4985e42c5e
--- /dev/null
+++ b/.devin/rules/40-vue-components.md
@@ -0,0 +1,14 @@
+---
+trigger: glob
+globs: **/*.vue
+---
+
+# Vue 3 Component Rules
+
+- Vue 3 SFCs. Use `<script setup>` for new components when practical.
+- `component-name-in-template-casing: PascalCase` (enforced).
+- Filenames PascalCase. One component per file.
+- Do not mutate props in new code (the ESLint rule is currently disabled but
+  treat mutation as forbidden).
+- Follow `vue/first-attribute-linebreak` conventions.
+- Keep templates dumb; put logic in composables or the plugin's JS module.
diff --git a/.devin/rules/50-commits-and-prs.md b/.devin/rules/50-commits-and-prs.md
new file mode 100644
index 0000000000..37602d5ea1
--- /dev/null
+++ b/.devin/rules/50-commits-and-prs.md
@@ -0,0 +1,14 @@
+---
+trigger: always_on
+---
+
+# Commits & PRs
+
+- Subject line ≤54 chars, imperative mood, prefix subsystem in brackets:
+  `[Telemetry] Handle empty request response`.
+- Body wraps at ~72 chars. Reference issue: `Closes #1234` or
+  `Addresses #1234`.
+- Every PR links to an issue and includes testing instructions.
+- Do not squash lint/format fixes into unrelated commits.
+- Changes to public API require senior-developer approval per
+  `CONTRIBUTING.md`.
diff --git a/.devin/workflows/add-e2e-test.md b/.devin/workflows/add-e2e-test.md
new file mode 100644
index 0000000000..b6708a451d
--- /dev/null
+++ b/.devin/workflows/add-e2e-test.md
@@ -0,0 +1,17 @@
+---
+description: Add a Playwright e2e spec
+---
+
+# Add E2E Test
+
+1. Choose folder: `e2e/tests/functional/` (default) or
+   `e2e/tests/visual-a11y/` for a11y/visual specs.
+2. Filename: `<feature>.e2e.spec.js`.
+3. Import from `../../baseFixtures.js` (or a more specific fixture in
+   `e2e/`).
+4. Use `page.goto('./')`, then interact via role/label locators (prefer
+   `getByRole`, `getByLabel` over CSS selectors).
+5. Tag if needed: `test('does thing @a11y', ...)` — CI grep filters use these.
+6. Local run: `npm run test:e2e:local -- <grep> --debug`.
+7. If snapshot-based, run inside the Playwright docker image (see
+   `e2e/README.md`) to match CI rendering exactly.
diff --git a/.devin/workflows/add-object-type.md b/.devin/workflows/add-object-type.md
new file mode 100644
index 0000000000..309ec6d75d
--- /dev/null
+++ b/.devin/workflows/add-object-type.md
@@ -0,0 +1,26 @@
+---
+description: Register a new domain-object type
+---
+
+# Add Object Type
+
+1. Pick a namespaced key: `<vendor>.<name>`.
+2. Register:
+
+   ```js
+   openmct.types.addType(key, {
+     name,
+     description,
+     cssClass,
+     creatable,
+     initialize(model) {
+       // default fields on new instances
+     }
+   });
+   ```
+
+3. If `creatable: true`, add form fields via `openmct.forms` if needed.
+4. Provide a view:
+   `openmct.objectViews.addProvider({ key, name, canView, view })`.
+5. Test: install plugin, `expect(openmct.types.get(key)).toBeDefined()` and
+   assert the view provider returns a view for objects of that type.
diff --git a/.devin/workflows/add-telemetry-source.md b/.devin/workflows/add-telemetry-source.md
new file mode 100644
index 0000000000..b75df8e312
--- /dev/null
+++ b/.devin/workflows/add-telemetry-source.md
@@ -0,0 +1,21 @@
+---
+description: Add a new telemetry provider (historical + realtime)
+---
+
+# Add Telemetry Source
+
+1. Model the telemetry object: define `type`, `telemetry.values[]` with `key`,
+   `name`, `format`, `hints` (domain=time, range=value). Must include a value
+   whose `key` matches the active time system (`utc` by default). Use
+   `source` when the raw field name differs from the metadata `key`.
+2. Register an object provider that returns this object for a namespace.
+3. Register a telemetry provider:
+   - `supportsRequest(obj, opts)` + `request(obj, opts)` for history —
+     return `Promise<Datum[]>` sorted ascending by domain.
+   - `supportsSubscribe(obj)` + `subscribe(obj, cb, opts)` for realtime —
+     return an unsubscribe function.
+4. Handle `opts.strategy` (`latest`, `minmax`) if the backend supports it.
+5. Unit-test: install plugin, mock `fetch` / network via `spyOnBuiltins`, assert
+   that requesting your object yields expected datums.
+6. Reference: `src/plugins/conjunctionSSA/SsaTelemetryProvider.js` and
+   `example/generator/`.
diff --git a/.devin/workflows/add-unit-test.md b/.devin/workflows/add-unit-test.md
new file mode 100644
index 0000000000..5f8e5bb3d2
--- /dev/null
+++ b/.devin/workflows/add-unit-test.md
@@ -0,0 +1,34 @@
+---
+description: Add a Karma+Jasmine unit test alongside source
+---
+
+# Add Unit Test
+
+1. Create `FooSpec.js` next to `Foo.js`.
+2. Skeleton:
+
+   ```js
+   import { createOpenMct, resetApplicationState } from 'utils/testing';
+   import MyPlugin from './plugin.js';
+
+   describe('MyPlugin', () => {
+     let openmct;
+
+     beforeEach((done) => {
+       openmct = createOpenMct();
+       openmct.install(MyPlugin());
+       openmct.on('start', done);
+       openmct.startHeadless();
+     });
+
+     afterEach(() => resetApplicationState(openmct));
+
+     it('registers its type', () => {
+       expect(openmct.types.get('my.type')).toBeDefined();
+     });
+   });
+   ```
+
+3. Run `npm test` (or `npm run test:debug` for a live Chrome).
+4. Do not import private modules; assert only on the public API surface.
+5. Clean up any `spyOnBuiltins` via `resetApplicationState`.
diff --git a/.devin/workflows/add-view.md b/.devin/workflows/add-view.md
new file mode 100644
index 0000000000..6ba6259c17
--- /dev/null
+++ b/.devin/workflows/add-view.md
@@ -0,0 +1,17 @@
+---
+description: Add a view provider for a domain-object type
+---
+
+# Add View
+
+1. Create `MyView.vue` under `components/`.
+2. Implement view provider:
+   - `key`, `name`, `cssClass`
+   - `canView(domainObject)` → boolean
+   - `view(domainObject, objectPath)` → `{ show(el, isEditing, viewOptions), destroy() }`
+3. In `show`, mount a Vue app into `element`. Wrap animation work in
+   `viewOptions.renderWhenVisible(fn)` so it defers while offscreen.
+4. In `destroy`, unmount the app and remove listeners / subscriptions.
+5. Register: `openmct.objectViews.addProvider(provider)`.
+6. Reference: `src/plugins/gauge/GaugeViewProvider.js` for a minimal view;
+   `src/plugins/plot/` for a large, telemetry-driven one.
diff --git a/.devin/workflows/debug-flaky-test.md b/.devin/workflows/debug-flaky-test.md
new file mode 100644
index 0000000000..cf4f5c17ae
--- /dev/null
+++ b/.devin/workflows/debug-flaky-test.md
@@ -0,0 +1,25 @@
+---
+description: Triage a flaky Karma or Playwright test
+---
+
+# Debug Flaky Test
+
+1. Reproduce locally: `npm test` or
+   `npm run test:e2e:local -- <grep>`.
+2. Reset workspace if needed:
+   `nvm use && npm run clean && npm install`.
+3. For e2e, run in the official container to match CI:
+
+   ```sh
+   docker run --rm --network host -v $(pwd):/work -w /work -it \
+     mcr.microsoft.com/playwright:v<X.X.X>-jammy /bin/bash
+   ```
+
+4. Check CircleCI test insights for historical flake rate.
+5. Common root causes:
+   - Unresolved promises / missing `await`.
+   - Animation timing (missing `renderWhenVisible` or `waitFor`).
+   - Uncleaned spies (call `resetApplicationState` in `afterEach`).
+   - URL hash pollution between tests.
+6. Fix the root cause. Do NOT add arbitrary `waitForTimeout` — prefer
+   `expect(...).toBeVisible()` or `waitFor` on observable state.
diff --git a/.devin/workflows/new-plugin.md b/.devin/workflows/new-plugin.md
new file mode 100644
index 0000000000..d5ddb2ab3b
--- /dev/null
+++ b/.devin/workflows/new-plugin.md
@@ -0,0 +1,30 @@
+---
+description: Scaffold a new Open MCT plugin end-to-end
+---
+
+# New Plugin
+
+Inputs to gather: `pluginName` (PascalCase), `namespace` (dot.notation),
+whether it registers types / providers / views.
+
+1. Create `src/plugins/<camelName>/` with:
+   - `plugin.js` — export default factory returning the install function.
+   - `pluginSpec.js` — colocated Jasmine spec that installs the plugin
+     against `createOpenMct()` and asserts registered artifacts.
+   - `README.md` — sections: "What it registers", "Files", "Installation",
+     "Caveats".
+2. If it registers a type:
+   `openmct.types.addType('<namespace>.<key>', { name, description, cssClass, creatable })`.
+3. If it registers a root object: implement an object provider class with
+   `get(identifier)` and call:
+   - `openmct.objects.addRoot(id, openmct.priority.LOW)`
+   - `openmct.objects.addProvider(namespace, { get })`
+4. If it provides telemetry: implement `supportsRequest` / `request` and/or
+   `supportsSubscribe` / `subscribe`. `subscribe` must return an unsubscribe
+   function.
+5. Register in `src/plugins/plugins.js`: import and assign
+   `plugins.<Name> = <Name>Plugin;`.
+6. Add to `index.html`'s install block if it should ship in the demo.
+7. Run `npm run lint` and `npm test`.
+
+Reference: `src/plugins/conjunctionSSA/` is a full-featured template.
diff --git a/.devin/workflows/release-checks.md b/.devin/workflows/release-checks.md
new file mode 100644
index 0000000000..6af7e97c49
--- /dev/null
+++ b/.devin/workflows/release-checks.md
@@ -0,0 +1,15 @@
+---
+description: Pre-merge / pre-release verification
+---
+
+# Release Checks
+
+1. `nvm use`
+2. `npm run clean && npm install`
+3. `npm run lint`
+4. `npm test`
+5. `npm run test:e2e:ci`
+6. `npm run build:prod` — confirm `dist/openmct.js` is produced.
+7. Verify no new large runtime deps landed in `package.json`.
+8. Update copyright if crossing a year boundary
+   (`npm run update-copyright-date`).
diff --git a/.devin/workflows/review.md b/.devin/workflows/review.md
new file mode 100644
index 0000000000..6595c4a6cd
--- /dev/null
+++ b/.devin/workflows/review.md
@@ -0,0 +1,22 @@
+---
+auto_execution_mode: 0
+description: Review code changes for bugs, security issues, and improvements
+---
+You are a senior software engineer performing a thorough code review to identify potential bugs.
+
+Your task is to find all potential bugs and code improvements in the code changes. Focus on:
+1. Logic errors and incorrect behavior
+2. Edge cases that aren't handled
+3. Null/undefined reference issues
+4. Race conditions or concurrency issues
+5. Security vulnerabilities
+6. Improper resource management or resource leaks
+7. API contract violations
+8. Incorrect caching behavior, including cache staleness issues, cache key-related bugs, incorrect cache invalidation, and ineffective caching
+9. Violations of existing code patterns or conventions
+
+Make sure to:
+1. If exploring the codebase, call multiple tools in parallel for increased efficiency. Do not spend too much time exploring.
+2. If you find any pre-existing bugs in the code, you should also report those since it's important for us to maintain general code quality for the user.
+3. Do NOT report issues that are speculative or low-confidence. All your conclusions should be based on a complete understanding of the codebase.
+4. Remember that if you were given a specific git commit, it may not be checked out and local code states may be different.
\ No newline at end of file
diff --git a/.devin/workflows/upgrade-dep.md b/.devin/workflows/upgrade-dep.md
new file mode 100644
index 0000000000..0abd16387f
--- /dev/null
+++ b/.devin/workflows/upgrade-dep.md
@@ -0,0 +1,13 @@
+---
+description: Upgrade a dependency safely
+---
+
+# Upgrade Dependency
+
+1. Check `browserslist` compatibility in `package.json`.
+2. `npm i <pkg>@<version>` — update lockfile.
+3. Read release notes for breaking changes.
+4. `npm run lint && npm test && npm run test:e2e:ci`.
+5. `npm run build:prod`, then manually smoke-test with `npm start`.
+6. If it affects `d3`, `plotly`, `vue`, `webpack`, `playwright`, or `karma`,
+   flag for extra review — these touch many files.
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000..7b86b90edf
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,48 @@
+# Agent Primer — Open MCT
+
+Open MCT is NASA Ames' browser-based mission-control framework. It ships as an
+npm library (`openmct`) and is composed almost entirely of **plugins** that
+register against a stable core API (`src/api/`).
+
+## Read first
+
+- `README.md`, `API.md`, `TESTING.md`, `CONTRIBUTING.md`
+- `.devin/rules/00-project-overview.md`
+- `.agent/knowledge/architecture.md`
+
+## Core rules
+
+- Prefer the public API (`openmct.*`) over internal modules.
+- Follow ESLint + Prettier; do not weaken lint rules to make code pass.
+- Colocate `*Spec.js` unit tests with the source they test.
+- Never delete or weaken tests without explicit direction.
+- Vue 3 SFC components use PascalCase filenames; JS files exporting a class use
+  PascalCase, other JS files use camelCase.
+- Do not introduce new runtime dependencies without justification.
+
+## Common commands
+
+- `npm start` — dev server at <http://localhost:8080>
+- `npm test` — Karma + Jasmine unit tests
+- `npm run test:debug` — unit tests in a live Chrome session
+- `npm run test:e2e:ci` — Playwright e2e (CI parity)
+- `npm run test:e2e:local -- <grep> --debug` — local e2e iteration
+- `npm run lint` / `npm run lint:fix`
+- `npm run build:prod` — produce `dist/openmct.js`
+
+Node version: see `engines.node` in `package.json` (currently `>=24.14.1`).
+Use `nvm use` to select the version pinned by `.nvmrc`.
+
+## Where things live
+
+- `openmct.js` → `src/MCT.js` — entry point.
+- `src/api/` — extension-point APIs (objects, composition, telemetry, time,
+  types, actions, forms, indicators, priority, user, menu, notifications,
+  tooltips, overlays, annotation, status).
+- `src/plugins/` — ~66 built-in plugins, aggregated by `src/plugins/plugins.js`.
+- `example/` — small illustrative plugins.
+- `e2e/` — Playwright tests, fixtures, and helpers.
+- `.webpack/` — webpack configs.
+- `.devin/rules/` — always-on and glob-triggered agent rules.
+- `.devin/workflows/` — invokable playbooks (`/name`).
+- `.agent/knowledge/` — reference dossiers, opt-in.
diff --git a/index.html b/index.html
index 42417f0022..3b04ab1153 100644
--- a/index.html
+++ b/index.html
@@ -236,6 +236,7 @@
       openmct.install(openmct.plugins.BarChart());
       openmct.install(openmct.plugins.ScatterPlot());
       openmct.install(openmct.plugins.EventTimestripPlugin(timeLinePlugin.extendedLinesBus));
+      openmct.install(openmct.plugins.ConjunctionSSA());
       document.addEventListener('DOMContentLoaded', function () {
         openmct.start();
       });
diff --git a/src/plugins/conjunctionSSA/ConjunctionEngine.js b/src/plugins/conjunctionSSA/ConjunctionEngine.js
new file mode 100644
index 0000000000..a485e99952
--- /dev/null
+++ b/src/plugins/conjunctionSSA/ConjunctionEngine.js
@@ -0,0 +1,291 @@
+import { probabilityOfCollision } from './pc.js';
+import { distanceKm, eciToGeodetic, propagateEci, speedKmS } from './propagator.js';
+import { parseTle } from './tles.js';
+
+const DEFAULT_LOOK_AHEAD_SECONDS = 30 * 60;
+const DEFAULT_COARSE_STEP_SECONDS = 30;
+const DEFAULT_REFINEMENT_TOLERANCE_SECONDS = 1;
+const DEFAULT_TICK_INTERVAL_MS = 5000;
+const HISTORY_BUFFER_SIZE = 500;
+const GOLDEN_RATIO = (Math.sqrt(5) - 1) / 2;
+const GOLDEN_MAX_ITER = 50;
+
+function pairKey(a, b) {
+  return a < b ? `${a}__${b}` : `${b}__${a}`;
+}
+
+function pushCapped(buffer, datum, cap) {
+  buffer.push(datum);
+  if (buffer.length > cap) {
+    buffer.shift();
+  }
+}
+
+class ConjunctionEngine {
+  constructor(options = {}) {
+    this.lookAheadSeconds = options.lookAheadSeconds ?? DEFAULT_LOOK_AHEAD_SECONDS;
+    this.coarseStepSeconds = options.coarseStepSeconds ?? DEFAULT_COARSE_STEP_SECONDS;
+    this.refinementToleranceSeconds =
+      options.refinementToleranceSeconds ?? DEFAULT_REFINEMENT_TOLERANCE_SECONDS;
+    this.tickIntervalMs = options.tickIntervalMs ?? DEFAULT_TICK_INTERVAL_MS;
+    this.now = options.now ?? (() => Date.now());
+    this.pcOptions = options.pcOptions ?? {};
+
+    this.elementsById = new Map();
+    this.trackedIds = [];
+    this.history = new Map();
+    this.subscribers = new Map();
+    this.timerId = null;
+
+    if (options.seeds) {
+      options.seeds.forEach((seed) => this.addTracked(seed));
+    }
+  }
+
+  addTracked(seed) {
+    const elements = parseTle(seed.tle1, seed.tle2);
+    this.elementsById.set(seed.id, { seed, elements });
+    if (!this.trackedIds.includes(seed.id)) {
+      this.trackedIds.push(seed.id);
+    }
+    this.history.set(`tracked:${seed.id}`, []);
+    if (!this.history.has('pair:summary')) {
+      this.history.set('pair:summary', []);
+    }
+    this.trackedIds.forEach((otherId) => {
+      if (otherId === seed.id) {
+        return;
+      }
+      this.history.set(`pair:${pairKey(seed.id, otherId)}`, []);
+    });
+  }
+
+  listPairs() {
+    const pairs = [];
+    for (let i = 0; i < this.trackedIds.length; i += 1) {
+      for (let j = i + 1; j < this.trackedIds.length; j += 1) {
+        pairs.push({
+          primaryId: this.trackedIds[i],
+          secondaryId: this.trackedIds[j],
+          key: pairKey(this.trackedIds[i], this.trackedIds[j])
+        });
+      }
+    }
+    return pairs;
+  }
+
+  propagateTracked(id, timestampMs) {
+    const entry = this.elementsById.get(id);
+    if (!entry) {
+      throw new Error(`Unknown tracked object: ${id}`);
+    }
+    const state = propagateEci(entry.elements, timestampMs);
+    const geodetic = eciToGeodetic(state.position, timestampMs);
+    return {
+      utc: timestampMs,
+      lat: geodetic.latDeg,
+      lon: geodetic.lonDeg,
+      alt: geodetic.altKm,
+      speedKmS: speedKmS(state.velocity),
+      eci: state.position
+    };
+  }
+
+  screenPair(primaryId, secondaryId, startMs, endMs) {
+    const primaryEntry = this.elementsById.get(primaryId);
+    const secondaryEntry = this.elementsById.get(secondaryId);
+    if (!primaryEntry || !secondaryEntry) {
+      throw new Error('Unknown pair member');
+    }
+
+    const stepMs = this.coarseStepSeconds * 1000;
+    let previousDistance = Infinity;
+    let previousPreviousDistance = Infinity;
+    let previousTime = startMs;
+    let previousPreviousTime = startMs;
+    let bestBracket = null;
+    let bestBracketMiss = Infinity;
+
+    for (let t = startMs; t <= endMs; t += stepMs) {
+      const primaryState = propagateEci(primaryEntry.elements, t);
+      const secondaryState = propagateEci(secondaryEntry.elements, t);
+      const d = distanceKm(primaryState.position, secondaryState.position);
+
+      if (
+        previousPreviousDistance !== Infinity &&
+        previousDistance < previousPreviousDistance &&
+        previousDistance < d &&
+        previousDistance < bestBracketMiss
+      ) {
+        bestBracketMiss = previousDistance;
+        bestBracket = [previousPreviousTime, t];
+      }
+
+      previousPreviousDistance = previousDistance;
+      previousPreviousTime = previousTime;
+      previousDistance = d;
+      previousTime = t;
+    }
+
+    if (!bestBracket) {
+      return null;
+    }
+
+    const refined = this.refineTca(primaryEntry.elements, secondaryEntry.elements, bestBracket);
+    return {
+      tcaMs: refined.tcaMs,
+      missKm: refined.missKm,
+      pc: probabilityOfCollision(refined.missKm, this.pcOptions)
+    };
+  }
+
+  refineTca(primaryElements, secondaryElements, bracket) {
+    let [lo, hi] = bracket;
+    let iter = 0;
+    while (hi - lo > this.refinementToleranceSeconds * 1000 && iter < GOLDEN_MAX_ITER) {
+      const c = hi - (hi - lo) * GOLDEN_RATIO;
+      const d = lo + (hi - lo) * GOLDEN_RATIO;
+      const dc = distanceKm(
+        propagateEci(primaryElements, c).position,
+        propagateEci(secondaryElements, c).position
+      );
+      const dd = distanceKm(
+        propagateEci(primaryElements, d).position,
+        propagateEci(secondaryElements, d).position
+      );
+      if (dc < dd) {
+        hi = d;
+      } else {
+        lo = c;
+      }
+      iter += 1;
+    }
+    const tcaMs = (lo + hi) / 2;
+    const missKm = distanceKm(
+      propagateEci(primaryElements, tcaMs).position,
+      propagateEci(secondaryElements, tcaMs).position
+    );
+    return { tcaMs, missKm };
+  }
+
+  screenAllPairs(nowMs) {
+    const endMs = nowMs + this.lookAheadSeconds * 1000;
+    const results = [];
+    this.listPairs().forEach(({ primaryId, secondaryId, key }) => {
+      const screening = this.screenPair(primaryId, secondaryId, nowMs, endMs);
+      const datum = {
+        utc: nowMs,
+        pairKey: key,
+        primary: primaryId,
+        secondary: secondaryId,
+        missKm: screening ? screening.missKm : NaN,
+        tcaMs: screening ? screening.tcaMs : nowMs,
+        tcaOffsetS: screening ? (screening.tcaMs - nowMs) / 1000 : NaN,
+        pc: screening ? screening.pc : 0
+      };
+      results.push(datum);
+      const buffer = this.history.get(`pair:${key}`);
+      if (buffer) {
+        pushCapped(buffer, datum, HISTORY_BUFFER_SIZE);
+      }
+    });
+    return results;
+  }
+
+  emit(historyKey, datum) {
+    const subs = this.subscribers.get(historyKey);
+    if (!subs) {
+      return;
+    }
+    subs.forEach((cb) => cb(datum));
+  }
+
+  tick() {
+    const nowMs = this.now();
+    this.trackedIds.forEach((id) => {
+      const datum = this.propagateTracked(id, nowMs);
+      const buffer = this.history.get(`tracked:${id}`);
+      if (buffer) {
+        pushCapped(buffer, datum, HISTORY_BUFFER_SIZE);
+      }
+      this.emit(`tracked:${id}`, datum);
+    });
+    const pairs = this.screenAllPairs(nowMs);
+    pairs.forEach((datum) => {
+      this.emit(`pair:${datum.pairKey}`, datum);
+    });
+    const summary = this.summarize(pairs, nowMs);
+    const summaryBuffer = this.history.get('pair:summary');
+    if (summaryBuffer) {
+      pushCapped(summaryBuffer, summary, HISTORY_BUFFER_SIZE);
+    }
+    this.emit('pair:summary', summary);
+  }
+
+  summarize(pairDatums, nowMs) {
+    let worst = null;
+    pairDatums.forEach((datum) => {
+      if (Number.isNaN(datum.missKm)) {
+        return;
+      }
+      if (!worst || datum.pc > worst.pc || datum.missKm < worst.missKm) {
+        worst = datum;
+      }
+    });
+    if (!worst) {
+      return {
+        utc: nowMs,
+        pairKey: 'summary',
+        primary: '',
+        secondary: '',
+        missKm: Infinity,
+        tcaOffsetS: NaN,
+        pc: 0
+      };
+    }
+    return {
+      utc: nowMs,
+      pairKey: 'summary',
+      primary: worst.primary,
+      secondary: worst.secondary,
+      missKm: worst.missKm,
+      tcaOffsetS: worst.tcaOffsetS,
+      pc: worst.pc
+    };
+  }
+
+  start() {
+    if (this.timerId !== null) {
+      return;
+    }
+    this.tick();
+    this.timerId = setInterval(() => this.tick(), this.tickIntervalMs);
+  }
+
+  stop() {
+    if (this.timerId !== null) {
+      clearInterval(this.timerId);
+      this.timerId = null;
+    }
+  }
+
+  subscribe(historyKey, callback) {
+    if (!this.subscribers.has(historyKey)) {
+      this.subscribers.set(historyKey, new Set());
+    }
+    this.subscribers.get(historyKey).add(callback);
+    return () => {
+      const subs = this.subscribers.get(historyKey);
+      if (subs) {
+        subs.delete(callback);
+      }
+    };
+  }
+
+  getHistory(historyKey, startMs, endMs) {
+    const buffer = this.history.get(historyKey) ?? [];
+    return buffer.filter((datum) => datum.utc >= startMs && datum.utc <= endMs);
+  }
+}
+
+export { ConjunctionEngine, pairKey };
diff --git a/src/plugins/conjunctionSSA/ConjunctionEngineSpec.js b/src/plugins/conjunctionSSA/ConjunctionEngineSpec.js
new file mode 100644
index 0000000000..e65cb04c12
--- /dev/null
+++ b/src/plugins/conjunctionSSA/ConjunctionEngineSpec.js
@@ -0,0 +1,106 @@
+import { ConjunctionEngine, pairKey } from './ConjunctionEngine.js';
+import { SEED_TLES } from './tles.js';
+
+const ISS_SEED = SEED_TLES.find((tle) => tle.id === '25544');
+const CHASER_SEED = SEED_TLES.find((tle) => tle.id === '99999');
+const HST_SEED = SEED_TLES.find((tle) => tle.id === '20580');
+
+function makeEngineAt(nowMs, seeds) {
+  return new ConjunctionEngine({
+    seeds,
+    now: () => nowMs,
+    tickIntervalMs: 60_000,
+    lookAheadSeconds: 30 * 60,
+    coarseStepSeconds: 30
+  });
+}
+
+describe('ConjunctionEngine', () => {
+  it('registers a history buffer for each tracked object and pair', () => {
+    const engine = makeEngineAt(ISS_SEED.tle1 ? Date.UTC(2024, 0, 1, 12) : 0, [ISS_SEED, HST_SEED]);
+    expect(engine.trackedIds).toEqual(['25544', '20580']);
+    expect(engine.listPairs()).toEqual([
+      { primaryId: '25544', secondaryId: '20580', key: pairKey('25544', '20580') }
+    ]);
+    expect(engine.getHistory(`tracked:25544`, -Infinity, Infinity)).toEqual([]);
+  });
+
+  it('produces a tracked telemetry datum on tick', () => {
+    const nowMs = Date.UTC(2024, 0, 1, 12);
+    const engine = makeEngineAt(nowMs, [ISS_SEED]);
+    engine.tick();
+    const history = engine.getHistory('tracked:25544', -Infinity, Infinity);
+    expect(history.length).toBe(1);
+    expect(history[0].utc).toBe(nowMs);
+    expect(Number.isFinite(history[0].lat)).toBeTrue();
+    expect(Number.isFinite(history[0].lon)).toBeTrue();
+    expect(history[0].alt).toBeGreaterThan(300);
+  });
+
+  it('screens the ISS vs synthetic chaser pair and finds a close approach', () => {
+    const nowMs = Date.UTC(2024, 0, 1, 12);
+    const engine = makeEngineAt(nowMs, [ISS_SEED, CHASER_SEED]);
+    engine.tick();
+    const pairHistoryKey = `pair:${pairKey('25544', '99999')}`;
+    const [datum] = engine.getHistory(pairHistoryKey, -Infinity, Infinity);
+    expect(datum).toBeDefined();
+    expect(datum.missKm).toBeLessThan(200);
+    expect(datum.pc).toBeGreaterThanOrEqual(0);
+    expect(datum.tcaOffsetS).toBeGreaterThanOrEqual(0);
+  });
+
+  it('emits a worst-case summary datum with the smallest pair miss distance', () => {
+    const nowMs = Date.UTC(2024, 0, 1, 12);
+    const engine = makeEngineAt(nowMs, [ISS_SEED, CHASER_SEED, HST_SEED]);
+    engine.tick();
+    const [summary] = engine.getHistory('pair:summary', -Infinity, Infinity);
+    const pairs = engine
+      .listPairs()
+      .map((p) => {
+        const [entry] = engine.getHistory(`pair:${p.key}`, -Infinity, Infinity);
+        return entry.missKm;
+      })
+      .filter((missKm) => !Number.isNaN(missKm));
+    const smallestMiss = Math.min(...pairs);
+    expect(summary.missKm).toBeCloseTo(smallestMiss, 6);
+  });
+
+  it('reports NaN miss distance for pairs with no close approach in the window', () => {
+    const nowMs = Date.UTC(2024, 0, 1, 12);
+    const engine = makeEngineAt(nowMs, [ISS_SEED, HST_SEED]);
+    engine.tick();
+    const [datum] = engine.getHistory(`pair:${pairKey('25544', '20580')}`, -Infinity, Infinity);
+    expect(Number.isNaN(datum.missKm)).toBeTrue();
+    expect(Number.isNaN(datum.tcaOffsetS)).toBeTrue();
+    expect(datum.pc).toBe(0);
+  });
+
+  it('excludes non-converging pairs from the worst-case summary', () => {
+    const nowMs = Date.UTC(2024, 0, 1, 12);
+    const engine = makeEngineAt(nowMs, [ISS_SEED, CHASER_SEED, HST_SEED]);
+    engine.tick();
+    const [summary] = engine.getHistory('pair:summary', -Infinity, Infinity);
+    expect(Number.isFinite(summary.missKm)).toBeTrue();
+    expect(summary.pairKey).not.toContain('20580');
+  });
+
+  it('fires subscriber callbacks on tick', () => {
+    const engine = makeEngineAt(Date.UTC(2024, 0, 1, 12), [ISS_SEED, HST_SEED]);
+    const callback = jasmine.createSpy('subscriber');
+    const unsubscribe = engine.subscribe('tracked:25544', callback);
+    engine.tick();
+    expect(callback).toHaveBeenCalledTimes(1);
+    unsubscribe();
+    engine.tick();
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('caps history buffers at 500 entries', () => {
+    const engine = makeEngineAt(0, [ISS_SEED]);
+    for (let i = 0; i < 600; i += 1) {
+      engine.now = () => i * 1000;
+      engine.tick();
+    }
+    expect(engine.getHistory('tracked:25544', -Infinity, Infinity).length).toBe(500);
+  });
+});
diff --git a/src/plugins/conjunctionSSA/README.md b/src/plugins/conjunctionSSA/README.md
new file mode 100644
index 0000000000..e5d26f9dcb
--- /dev/null
+++ b/src/plugins/conjunctionSSA/README.md
@@ -0,0 +1,95 @@
+# Conjunction SSA Plugin
+
+Self-contained Open MCT plugin that streams satellite / debris state and
+per-pair conjunction telemetry from a seed set of public TLEs, using a plain
+Keplerian + J2 propagator (no external dependencies).
+
+## What it registers
+
+- **Types**
+  - `conjunction.ssa.tracked-object` — a satellite or debris object.
+  - `conjunction.ssa.pair` — a screened pair of tracked objects.
+- **Root** `conjunction.ssa:root` containing:
+  - `Tracked Objects` folder with one child per seed TLE.
+  - `Conjunction Pairs` folder with one child per unordered pair.
+  - `Worst-Case Conjunction` summary pair endpoint.
+  - `Conjunction Watch` condition set (RED / YELLOW / GREEN).
+  - `Ranked Conjunctions` telemetry table.
+  - `Miss Distance vs Time` overlay plot.
+  - `Conjunction Operator Layout` display layout embedding all three.
+- **Telemetry provider** streaming:
+  - Tracked object: `utc`, `lat` (deg), `lon` (deg), `alt` (km), `speedKmS`.
+  - Pair: `utc`, `missKm`, `tcaOffsetS`, `pc`, `primary`, `secondary`, `pairKey`.
+
+## No-conjunction behaviour
+
+A pair only yields a miss distance if the coarse scan finds a **local minimum**
+of separation inside the look-ahead window. Pairs in very different orbital
+regimes frequently have no such minimum in a 30-minute window.
+
+When that happens the engine emits, for that pair:
+
+- `missKm` — `NaN`
+- `tcaOffsetS` — `NaN`
+- `pc` — `0`
+
+`NaN` is the deliberate sentinel for "no close approach found in this window",
+not an error. Open MCT renders it as a gap in the series. The
+`Worst-Case Conjunction` summary excludes these pairs, so the summary always
+reports a finite miss distance for the closest *converging* pair.
+
+Consumers computing aggregates over pair telemetry must filter `NaN` first —
+`Math.min` over unfiltered values returns `NaN`.
+
+## Condition Watch thresholds
+
+- **RED — Maneuver review**: `missKm < 5` AND `pc > 1e-4`.
+- **YELLOW — Close approach**: `missKm < 25` OR `pc > 1e-6`.
+- **GREEN — Nominal**: default.
+
+## Files
+
+- `plugin.js` — factory + install function.
+- `tles.js` — seed TLE list and `parseTle`.
+- `propagator.js` — Kepler solver, J2 secular rates, ECI/ECEF/geodetic.
+- `pc.js` — Foster-style 2D-Gaussian analytic Pc.
+- `ConjunctionEngine.js` — periodic tracked propagation, all-pair screening,
+  golden-section TCA refinement, summary aggregation.
+- `models.js` — pre-built domain-object models (folders, condition set, table,
+  plot, layout).
+- `SsaObjectProvider.js`, `SsaMetadataProvider.js`, `SsaTelemetryProvider.js`
+  — Open MCT provider glue.
+- `pluginSpec.js`, `propagatorSpec.js`, `pcSpec.js`,
+  `ConjunctionEngineSpec.js` — Jasmine specs.
+
+## Installation
+
+```js
+import openmct from 'openmct';
+openmct.install(openmct.plugins.ConjunctionSSA());
+```
+
+Options:
+
+- `seeds` — override the seed TLE list.
+- `lookAheadSeconds` — screening window (default 1800).
+- `coarseStepSeconds` — coarse propagation step (default 30).
+- `tickIntervalMs` — realtime refresh cadence (default 5000).
+- `pcOptions.hardBodyRadiusM` — HBR in metres (default 10).
+- `pcOptions.positionSigmaM` — combined 1σ position uncertainty (default 100).
+- `now` — clock override for tests.
+- `autoStart: false` — do not start the periodic tick timer.
+
+## Caveats — not for operational use
+
+- Propagation is **two-body Kepler + J2 secular only**. No SGP4, drag, SRP,
+  luni-solar, higher zonals or tesserals. Expect kilometre-scale drift within
+  hours of TLE epoch.
+- Geodetic conversion uses a **spherical Earth** (no WGS84 flattening).
+- Probability of collision is a **Foster / Alfano-style 2D isotropic Gaussian
+  approximation** with a fixed hard-body radius and diagonal position
+  covariance. Real Pc calculations require the encounter-plane covariance
+  projection from state-transition matrices and object dimensions.
+- Seed TLEs are static snapshots for demonstration and will be stale.
+- The `TEST CHASER (synthetic)` object is deliberately phased near ISS to
+  exercise the RED indicator; remove it for realistic operation.
diff --git a/src/plugins/conjunctionSSA/SsaMetadataProvider.js b/src/plugins/conjunctionSSA/SsaMetadataProvider.js
new file mode 100644
index 0000000000..3c524950e1
--- /dev/null
+++ b/src/plugins/conjunctionSSA/SsaMetadataProvider.js
@@ -0,0 +1,32 @@
+import { PAIR_TYPE, TRACKED_TYPE } from './models.js';
+
+const TRACKED_VALUES = [
+  { key: 'utc', name: 'Time', format: 'utc', hints: { domain: 1 } },
+  { key: 'lat', name: 'Latitude', unit: 'deg', format: 'float', hints: { range: 1 } },
+  { key: 'lon', name: 'Longitude', unit: 'deg', format: 'float', hints: { range: 2 } },
+  { key: 'alt', name: 'Altitude', unit: 'km', format: 'float', hints: { range: 3 } },
+  { key: 'speedKmS', name: 'Speed', unit: 'km/s', format: 'float', hints: { range: 4 } }
+];
+
+const PAIR_VALUES = [
+  { key: 'utc', name: 'Time', format: 'utc', hints: { domain: 1 } },
+  { key: 'pairKey', name: 'Pair', format: 'string' },
+  { key: 'primary', name: 'Primary', format: 'string' },
+  { key: 'secondary', name: 'Secondary', format: 'string' },
+  { key: 'missKm', name: 'Miss Distance', unit: 'km', format: 'float', hints: { range: 1 } },
+  { key: 'tcaOffsetS', name: 'TCA Offset', unit: 's', format: 'float', hints: { range: 2 } },
+  { key: 'pc', name: 'Probability of Collision', format: 'float', hints: { range: 3 } }
+];
+
+class SsaMetadataProvider {
+  supportsMetadata(domainObject) {
+    return domainObject.type === TRACKED_TYPE || domainObject.type === PAIR_TYPE;
+  }
+
+  getMetadata(domainObject) {
+    const values = domainObject.type === TRACKED_TYPE ? TRACKED_VALUES : PAIR_VALUES;
+    return { ...domainObject.telemetry, values };
+  }
+}
+
+export default SsaMetadataProvider;
diff --git a/src/plugins/conjunctionSSA/SsaObjectProvider.js b/src/plugins/conjunctionSSA/SsaObjectProvider.js
new file mode 100644
index 0000000000..e3e22c66e2
--- /dev/null
+++ b/src/plugins/conjunctionSSA/SsaObjectProvider.js
@@ -0,0 +1,15 @@
+class SsaObjectProvider {
+  constructor(modelMap) {
+    this.modelMap = modelMap;
+  }
+
+  get(identifier) {
+    const model = this.modelMap.get(identifier.key);
+    if (!model) {
+      return Promise.reject(new Error(`Unknown SSA object: ${identifier.key}`));
+    }
+    return Promise.resolve(JSON.parse(JSON.stringify(model)));
+  }
+}
+
+export default SsaObjectProvider;
diff --git a/src/plugins/conjunctionSSA/SsaTelemetryProvider.js b/src/plugins/conjunctionSSA/SsaTelemetryProvider.js
new file mode 100644
index 0000000000..bbb7c6bd39
--- /dev/null
+++ b/src/plugins/conjunctionSSA/SsaTelemetryProvider.js
@@ -0,0 +1,55 @@
+import { KEYS, PAIR_TYPE, TRACKED_TYPE } from './models.js';
+
+const TRACKED_PREFIX = 'tracked-';
+const PAIR_PREFIX = 'pair-';
+
+function historyKeyForObject(domainObject) {
+  const key = domainObject.identifier.key;
+  if (domainObject.type === TRACKED_TYPE && key.startsWith(TRACKED_PREFIX)) {
+    return `tracked:${key.slice(TRACKED_PREFIX.length)}`;
+  }
+  if (domainObject.type === PAIR_TYPE) {
+    if (key === KEYS.summary) {
+      return 'pair:summary';
+    }
+    if (key.startsWith(PAIR_PREFIX)) {
+      return `pair:${key.slice(PAIR_PREFIX.length)}`;
+    }
+  }
+  return null;
+}
+
+class SsaTelemetryProvider {
+  constructor(engine) {
+    this.engine = engine;
+  }
+
+  supportsRequest(domainObject) {
+    return historyKeyForObject(domainObject) !== null;
+  }
+
+  supportsSubscribe(domainObject) {
+    return historyKeyForObject(domainObject) !== null;
+  }
+
+  request(domainObject, options = {}) {
+    const historyKey = historyKeyForObject(domainObject);
+    if (!historyKey) {
+      return Promise.resolve([]);
+    }
+    const startMs = options.start ?? -Infinity;
+    const endMs = options.end ?? Infinity;
+    return Promise.resolve(this.engine.getHistory(historyKey, startMs, endMs));
+  }
+
+  subscribe(domainObject, callback) {
+    const historyKey = historyKeyForObject(domainObject);
+    if (!historyKey) {
+      return () => {};
+    }
+    return this.engine.subscribe(historyKey, callback);
+  }
+}
+
+export { historyKeyForObject };
+export default SsaTelemetryProvider;
diff --git a/src/plugins/conjunctionSSA/models.js b/src/plugins/conjunctionSSA/models.js
new file mode 100644
index 0000000000..3cfd031273
--- /dev/null
+++ b/src/plugins/conjunctionSSA/models.js
@@ -0,0 +1,331 @@
+const NAMESPACE = 'conjunction.ssa';
+
+const KEYS = {
+  root: 'root',
+  trackedFolder: 'tracked-folder',
+  pairFolder: 'pair-folder',
+  watch: 'conjunction-watch',
+  table: 'ranked-conjunctions-table',
+  plot: 'miss-distance-plot',
+  layout: 'operator-layout',
+  summary: 'pair-summary'
+};
+
+const TRACKED_TYPE = 'conjunction.ssa.tracked-object';
+const PAIR_TYPE = 'conjunction.ssa.pair';
+
+const RED_MISS_KM = 5;
+const RED_PC = 1e-4;
+const YELLOW_MISS_KM = 25;
+const YELLOW_PC = 1e-6;
+
+function id(key) {
+  return { namespace: NAMESPACE, key };
+}
+
+function trackedKey(seedId) {
+  return `tracked-${seedId}`;
+}
+
+function pairIdentifierKey(pairKey) {
+  return `pair-${pairKey}`;
+}
+
+function buildTrackedObject(seed) {
+  return {
+    identifier: id(trackedKey(seed.id)),
+    name: seed.name,
+    type: TRACKED_TYPE,
+    location: `${NAMESPACE}:${KEYS.trackedFolder}`,
+    telemetry: {
+      catalogNumber: seed.id,
+      group: seed.group,
+      tle1: seed.tle1,
+      tle2: seed.tle2
+    }
+  };
+}
+
+function buildPairObject(pair) {
+  return {
+    identifier: id(pairIdentifierKey(pair.key)),
+    name: `${pair.primaryId} × ${pair.secondaryId}`,
+    type: PAIR_TYPE,
+    location: `${NAMESPACE}:${KEYS.pairFolder}`,
+    telemetry: {
+      primary: pair.primaryId,
+      secondary: pair.secondaryId,
+      pairKey: pair.key
+    }
+  };
+}
+
+function buildSummaryObject() {
+  return {
+    identifier: id(KEYS.summary),
+    name: 'Worst-Case Conjunction',
+    type: PAIR_TYPE,
+    location: `${NAMESPACE}:${KEYS.root}`,
+    telemetry: {
+      pairKey: 'summary'
+    }
+  };
+}
+
+function buildWatchConditionSet() {
+  const summaryId = id(KEYS.summary);
+  return {
+    identifier: id(KEYS.watch),
+    name: 'Conjunction Watch',
+    type: 'conditionSet',
+    location: `${NAMESPACE}:${KEYS.root}`,
+    composition: [summaryId],
+    telemetry: {},
+    configuration: {
+      shouldFetchHistorical: false,
+      conditionTestData: [],
+      conditionCollection: [
+        {
+          id: 'conjunction-red',
+          configuration: {
+            name: 'RED - Maneuver review',
+            output: 'Maneuver review',
+            trigger: 'all',
+            criteria: [
+              {
+                id: 'red-miss',
+                telemetry: summaryId,
+                operation: 'lessThan',
+                input: [RED_MISS_KM],
+                metadata: 'missKm'
+              },
+              {
+                id: 'red-pc',
+                telemetry: summaryId,
+                operation: 'greaterThan',
+                input: [RED_PC],
+                metadata: 'pc'
+              }
+            ]
+          },
+          summary: `miss < ${RED_MISS_KM} km AND Pc > ${RED_PC}`
+        },
+        {
+          id: 'conjunction-yellow',
+          configuration: {
+            name: 'YELLOW - Close',
+            output: 'Close approach',
+            trigger: 'any',
+            criteria: [
+              {
+                id: 'yellow-miss',
+                telemetry: summaryId,
+                operation: 'lessThan',
+                input: [YELLOW_MISS_KM],
+                metadata: 'missKm'
+              },
+              {
+                id: 'yellow-pc',
+                telemetry: summaryId,
+                operation: 'greaterThan',
+                input: [YELLOW_PC],
+                metadata: 'pc'
+              }
+            ]
+          },
+          summary: `miss < ${YELLOW_MISS_KM} km OR Pc > ${YELLOW_PC}`
+        },
+        {
+          isDefault: true,
+          id: 'conjunction-green',
+          configuration: {
+            name: 'GREEN - Nominal',
+            output: 'Nominal',
+            trigger: 'all',
+            criteria: []
+          },
+          summary: 'No pair meets close-approach thresholds.'
+        }
+      ]
+    }
+  };
+}
+
+function buildTableObject(pairIdentifiers) {
+  return {
+    identifier: id(KEYS.table),
+    name: 'Ranked Conjunctions',
+    type: 'table',
+    location: `${NAMESPACE}:${KEYS.root}`,
+    composition: pairIdentifiers,
+    configuration: {
+      columnWidths: {},
+      hiddenColumns: {},
+      columnOrder: [],
+      cellFormat: {},
+      autosize: true
+    }
+  };
+}
+
+function buildPlotObject(pairIdentifiers) {
+  return {
+    identifier: id(KEYS.plot),
+    name: 'Miss Distance vs Time',
+    type: 'telemetry.plot.overlay',
+    location: `${NAMESPACE}:${KEYS.root}`,
+    composition: pairIdentifiers,
+    configuration: {
+      series: [],
+      yAxis: {
+        label: 'Miss Distance (km)',
+        autoscale: true
+      },
+      xAxis: {}
+    }
+  };
+}
+
+function buildLayoutObject() {
+  const watchId = id(KEYS.watch);
+  const tableId = id(KEYS.table);
+  const plotId = id(KEYS.plot);
+  return {
+    identifier: id(KEYS.layout),
+    name: 'Conjunction Operator Layout',
+    type: 'layout',
+    location: `${NAMESPACE}:${KEYS.root}`,
+    composition: [watchId, tableId, plotId],
+    configuration: {
+      items: [
+        {
+          type: 'subobject-view',
+          id: 'watch-item',
+          identifier: watchId,
+          x: 0,
+          y: 0,
+          width: 30,
+          height: 12,
+          hasFrame: true,
+          fontSize: 'default',
+          font: 'default'
+        },
+        {
+          type: 'subobject-view',
+          id: 'table-item',
+          identifier: tableId,
+          x: 30,
+          y: 0,
+          width: 60,
+          height: 30,
+          hasFrame: true,
+          fontSize: 'default',
+          font: 'default'
+        },
+        {
+          type: 'subobject-view',
+          id: 'plot-item',
+          identifier: plotId,
+          x: 0,
+          y: 12,
+          width: 30,
+          height: 30,
+          hasFrame: true,
+          fontSize: 'default',
+          font: 'default'
+        }
+      ],
+      layoutGrid: [10, 10],
+      objectStyles: {}
+    }
+  };
+}
+
+function buildTrackedFolder(trackedIdentifiers) {
+  return {
+    identifier: id(KEYS.trackedFolder),
+    name: 'Tracked Objects',
+    type: 'folder',
+    location: `${NAMESPACE}:${KEYS.root}`,
+    composition: trackedIdentifiers
+  };
+}
+
+function buildPairFolder(pairIdentifiers) {
+  return {
+    identifier: id(KEYS.pairFolder),
+    name: 'Conjunction Pairs',
+    type: 'folder',
+    location: `${NAMESPACE}:${KEYS.root}`,
+    composition: pairIdentifiers
+  };
+}
+
+function buildRoot(childrenIdentifiers) {
+  return {
+    identifier: id(KEYS.root),
+    name: 'Conjunction SSA',
+    type: 'folder',
+    location: 'ROOT',
+    composition: childrenIdentifiers
+  };
+}
+
+function buildAllModels(seeds, pairs) {
+  const trackedObjects = seeds.map(buildTrackedObject);
+  const trackedIdentifiers = trackedObjects.map((o) => o.identifier);
+  const pairObjects = pairs.map(buildPairObject);
+  const pairIdentifiers = pairObjects.map((o) => o.identifier);
+  const summary = buildSummaryObject();
+  const trackedFolder = buildTrackedFolder(trackedIdentifiers);
+  const pairFolder = buildPairFolder(pairIdentifiers);
+  const watch = buildWatchConditionSet();
+  const table = buildTableObject([summary.identifier, ...pairIdentifiers]);
+  const plot = buildPlotObject(pairIdentifiers);
+  const layout = buildLayoutObject();
+  const root = buildRoot([
+    trackedFolder.identifier,
+    pairFolder.identifier,
+    watch.identifier,
+    table.identifier,
+    plot.identifier,
+    layout.identifier
+  ]);
+
+  const map = new Map();
+  function insert(obj) {
+    map.set(obj.identifier.key, obj);
+  }
+  insert(root);
+  insert(trackedFolder);
+  insert(pairFolder);
+  insert(watch);
+  insert(table);
+  insert(plot);
+  insert(layout);
+  insert(summary);
+  trackedObjects.forEach(insert);
+  pairObjects.forEach(insert);
+  return map;
+}
+
+export {
+  buildAllModels,
+  buildLayoutObject,
+  buildPairObject,
+  buildRoot,
+  buildSummaryObject,
+  buildTrackedObject,
+  buildWatchConditionSet,
+  id,
+  KEYS,
+  NAMESPACE,
+  PAIR_TYPE,
+  pairIdentifierKey,
+  RED_MISS_KM,
+  RED_PC,
+  TRACKED_TYPE,
+  trackedKey,
+  YELLOW_MISS_KM,
+  YELLOW_PC
+};
diff --git a/src/plugins/conjunctionSSA/pc.js b/src/plugins/conjunctionSSA/pc.js
new file mode 100644
index 0000000000..49bfbe0943
--- /dev/null
+++ b/src/plugins/conjunctionSSA/pc.js
@@ -0,0 +1,14 @@
+const DEFAULT_HARD_BODY_RADIUS_M = 10;
+const DEFAULT_POSITION_SIGMA_M = 100;
+
+function probabilityOfCollision(missKm, options = {}) {
+  const hardBodyRadiusM = options.hardBodyRadiusM ?? DEFAULT_HARD_BODY_RADIUS_M;
+  const positionSigmaM = options.positionSigmaM ?? DEFAULT_POSITION_SIGMA_M;
+  const missM = missKm * 1000;
+  const sigmaSq = positionSigmaM * positionSigmaM;
+  const radiusSq = hardBodyRadiusM * hardBodyRadiusM;
+  const exponent = -(missM * missM) / (2 * sigmaSq);
+  return (radiusSq / (2 * sigmaSq)) * Math.exp(exponent);
+}
+
+export { DEFAULT_HARD_BODY_RADIUS_M, DEFAULT_POSITION_SIGMA_M, probabilityOfCollision };
diff --git a/src/plugins/conjunctionSSA/pcSpec.js b/src/plugins/conjunctionSSA/pcSpec.js
new file mode 100644
index 0000000000..2baf24b4ee
--- /dev/null
+++ b/src/plugins/conjunctionSSA/pcSpec.js
@@ -0,0 +1,29 @@
+import { probabilityOfCollision } from './pc.js';
+
+describe('probabilityOfCollision', () => {
+  it('is maximized at zero miss distance', () => {
+    const pcZero = probabilityOfCollision(0);
+    const pcSmall = probabilityOfCollision(0.05);
+    expect(pcZero).toBeGreaterThan(pcSmall);
+  });
+
+  it('decreases monotonically as miss distance increases', () => {
+    let previous = Infinity;
+    for (let missKm = 0; missKm <= 5; missKm += 0.5) {
+      const value = probabilityOfCollision(missKm);
+      expect(value).toBeLessThanOrEqual(previous);
+      previous = value;
+    }
+  });
+
+  it('scales with the hard-body radius squared', () => {
+    const smallHbr = probabilityOfCollision(0, { hardBodyRadiusM: 10 });
+    const largeHbr = probabilityOfCollision(0, { hardBodyRadiusM: 20 });
+    expect(largeHbr / smallHbr).toBeCloseTo(4, 6);
+  });
+
+  it('produces a value greater than 1e-4 for a very close approach', () => {
+    const pc = probabilityOfCollision(0.05, { hardBodyRadiusM: 10, positionSigmaM: 50 });
+    expect(pc).toBeGreaterThan(1e-4);
+  });
+});
diff --git a/src/plugins/conjunctionSSA/plugin.js b/src/plugins/conjunctionSSA/plugin.js
new file mode 100644
index 0000000000..a03f8e6d80
--- /dev/null
+++ b/src/plugins/conjunctionSSA/plugin.js
@@ -0,0 +1,53 @@
+import { ConjunctionEngine } from './ConjunctionEngine.js';
+import { buildAllModels, KEYS, NAMESPACE, PAIR_TYPE, TRACKED_TYPE } from './models.js';
+import SsaMetadataProvider from './SsaMetadataProvider.js';
+import SsaObjectProvider from './SsaObjectProvider.js';
+import SsaTelemetryProvider from './SsaTelemetryProvider.js';
+import { SEED_TLES } from './tles.js';
+
+function ConjunctionSSAPlugin(options = {}) {
+  const seeds = options.seeds ?? SEED_TLES;
+  const engine = new ConjunctionEngine({
+    seeds,
+    lookAheadSeconds: options.lookAheadSeconds,
+    coarseStepSeconds: options.coarseStepSeconds,
+    tickIntervalMs: options.tickIntervalMs,
+    pcOptions: options.pcOptions,
+    now: options.now
+  });
+
+  function install(openmct) {
+    openmct.types.addType(TRACKED_TYPE, {
+      name: 'Tracked Object',
+      description: 'A satellite or debris object propagated from TLE state.',
+      cssClass: 'icon-object',
+      creatable: false
+    });
+
+    openmct.types.addType(PAIR_TYPE, {
+      name: 'Conjunction Pair',
+      description: 'A screened pair of tracked objects with miss distance and Pc telemetry.',
+      cssClass: 'icon-object',
+      creatable: false
+    });
+
+    const pairs = engine.listPairs();
+    const modelMap = buildAllModels(seeds, pairs);
+    const objectProvider = new SsaObjectProvider(modelMap);
+
+    openmct.objects.addRoot({ namespace: NAMESPACE, key: KEYS.root }, openmct.priority.LOW);
+    openmct.objects.addProvider(NAMESPACE, objectProvider);
+    openmct.telemetry.addProvider(new SsaMetadataProvider());
+    openmct.telemetry.addProvider(new SsaTelemetryProvider(engine));
+
+    if (options.autoStart !== false) {
+      engine.start();
+      openmct.on('destroy', () => engine.stop());
+    }
+  }
+
+  install.engine = engine;
+  return install;
+}
+
+export default ConjunctionSSAPlugin;
diff --git a/src/plugins/conjunctionSSA/pluginSpec.js b/src/plugins/conjunctionSSA/pluginSpec.js
new file mode 100644
index 0000000000..2bf0a4b118
--- /dev/null
+++ b/src/plugins/conjunctionSSA/pluginSpec.js
@@ -0,0 +1,167 @@
+import { createOpenMct, resetApplicationState } from 'utils/testing';
+
+import { KEYS, NAMESPACE, PAIR_TYPE, TRACKED_TYPE } from './models.js';
+import ConjunctionSSAPlugin from './plugin.js';
+import { SEED_TLES } from './tles.js';
+
+const FIXED_NOW_MS = Date.UTC(2024, 0, 1, 12, 0, 0);
+const TEST_SEEDS = [
+  SEED_TLES.find((tle) => tle.id === '25544'),
+  SEED_TLES.find((tle) => tle.id === '99999'),
+  SEED_TLES.find((tle) => tle.id === '20580')
+];
+
+describe('ConjunctionSSA plugin', () => {
+  let openmct;
+  let pluginFactory;
+
+  beforeEach(() => {
+    openmct = createOpenMct();
+    pluginFactory = ConjunctionSSAPlugin({
+      seeds: TEST_SEEDS,
+      autoStart: false,
+      now: () => FIXED_NOW_MS
+    });
+  });
+
+  afterEach(() => {
+    if (pluginFactory && pluginFactory.engine) {
+      pluginFactory.engine.stop();
+    }
+    return resetApplicationState(openmct);
+  });
+
+  describe('before install', () => {
+    beforeEach((done) => {
+      openmct.on('start', done);
+      openmct.startHeadless();
+    });
+
+    it('does not register the tracked object type', () => {
+      expect(openmct.types.get(TRACKED_TYPE).key).toBe('unknown');
+    });
+
+    it('does not register the pair type', () => {
+      expect(openmct.types.get(PAIR_TYPE).key).toBe('unknown');
+    });
+
+    it('does not expose the Conjunction SSA root', async () => {
+      const rootCollection = openmct.composition.get({
+        identifier: { namespace: '', key: 'ROOT' },
+        type: 'root'
+      });
+      const rootChildren = await rootCollection.load();
+      const ssaRoot = rootChildren.find(
+        (child) => child.identifier.namespace === NAMESPACE && child.identifier.key === KEYS.root
+      );
+      expect(ssaRoot).toBeUndefined();
+    });
+  });
+
+  describe('after install', () => {
+    beforeEach((done) => {
+      openmct.install(pluginFactory);
+      openmct.on('start', done);
+      openmct.startHeadless();
+    });
+
+    it('registers the Tracked Object type', () => {
+      const type = openmct.types.get(TRACKED_TYPE);
+      expect(type).toBeDefined();
+      expect(type.definition.name).toBe('Tracked Object');
+    });
+
+    it('registers the Conjunction Pair type', () => {
+      const type = openmct.types.get(PAIR_TYPE);
+      expect(type).toBeDefined();
+    });
+
+    it('exposes a Conjunction SSA root object', async () => {
+      const root = await openmct.objects.get({ namespace: NAMESPACE, key: KEYS.root });
+      expect(root.name).toBe('Conjunction SSA');
+      expect(root.type).toBe('folder');
+      expect(root.composition.length).toBeGreaterThan(0);
+    });
+
+    it('exposes the Conjunction Watch condition set with three conditions', async () => {
+      const watch = await openmct.objects.get({ namespace: NAMESPACE, key: KEYS.watch });
+      expect(watch.type).toBe('conditionSet');
+      const outputs = watch.configuration.conditionCollection.map((c) => c.configuration.output);
+      expect(outputs).toEqual(['Maneuver review', 'Close approach', 'Nominal']);
+    });
+
+    it('exposes ranked table with the summary object first in composition', async () => {
+      const table = await openmct.objects.get({ namespace: NAMESPACE, key: KEYS.table });
+      expect(table.type).toBe('table');
+      expect(table.composition[0].key).toBe(KEYS.summary);
+    });
+
+    it('exposes an overlay plot for miss distance', async () => {
+      const plot = await openmct.objects.get({ namespace: NAMESPACE, key: KEYS.plot });
+      expect(plot.type).toBe('telemetry.plot.overlay');
+      expect(plot.composition.length).toBe((TEST_SEEDS.length * (TEST_SEEDS.length - 1)) / 2);
+    });
+
+    it('exposes an operator layout containing watch, table and plot subobjects', async () => {
+      const layout = await openmct.objects.get({ namespace: NAMESPACE, key: KEYS.layout });
+      expect(layout.type).toBe('layout');
+      const ids = layout.configuration.items.map((item) => item.identifier?.key);
+      expect(ids).toEqual([KEYS.watch, KEYS.table, KEYS.plot]);
+    });
+
+    it('provides tracked-object telemetry metadata with lat/lon/alt', async () => {
+      const iss = await openmct.objects.get({ namespace: NAMESPACE, key: 'tracked-25544' });
+      const metadata = openmct.telemetry.getMetadata(iss);
+      const valueKeys = metadata.values().map((v) => v.key);
+      expect(valueKeys).toContain('lat');
+      expect(valueKeys).toContain('lon');
+      expect(valueKeys).toContain('alt');
+      expect(valueKeys).toContain('utc');
+    });
+
+    it('provides pair telemetry metadata with missKm and pc', async () => {
+      const summary = await openmct.objects.get({ namespace: NAMESPACE, key: KEYS.summary });
+      const metadata = openmct.telemetry.getMetadata(summary);
+      const valueKeys = metadata.values().map((v) => v.key);
+      expect(valueKeys).toContain('missKm');
+      expect(valueKeys).toContain('pc');
+      expect(valueKeys).toContain('tcaOffsetS');
+    });
+
+    it('streams tracked telemetry to subscribers', (done) => {
+      openmct.objects.get({ namespace: NAMESPACE, key: 'tracked-25544' }).then((iss) => {
+        const unsubscribe = openmct.telemetry.subscribe(iss, (datum) => {
+          expect(datum.utc).toBe(FIXED_NOW_MS);
+          expect(Number.isFinite(datum.lat)).toBeTrue();
+          expect(datum.alt).toBeGreaterThan(300);
+          unsubscribe();
+          done();
+        });
+        pluginFactory.engine.tick();
+      });
+    });
+
+    it('streams pair telemetry with a computed miss distance', (done) => {
+      openmct.objects.get({ namespace: NAMESPACE, key: KEYS.summary }).then((summary) => {
+        const unsubscribe = openmct.telemetry.subscribe(summary, (datum) => {
+          expect(datum.missKm).toBeGreaterThanOrEqual(0);
+          expect(Number.isFinite(datum.pc)).toBeTrue();
+          unsubscribe();
+          done();
+        });
+        pluginFactory.engine.tick();
+      });
+    });
+
+    it('returns historical telemetry via request()', async () => {
+      const iss = await openmct.objects.get({ namespace: NAMESPACE, key: 'tracked-25544' });
+      pluginFactory.engine.tick();
+      const history = await openmct.telemetry.request(iss, {
+        start: FIXED_NOW_MS - 60_000,
+        end: FIXED_NOW_MS + 60_000
+      });
+      expect(history.length).toBeGreaterThan(0);
+      expect(history[0].utc).toBe(FIXED_NOW_MS);
+    });
+  });
+});
diff --git a/src/plugins/conjunctionSSA/propagator.js b/src/plugins/conjunctionSSA/propagator.js
new file mode 100644
index 0000000000..26728b799e
--- /dev/null
+++ b/src/plugins/conjunctionSSA/propagator.js
@@ -0,0 +1,140 @@
+const MU_EARTH_KM3_S2 = 398600.4418;
+const R_EARTH_KM = 6378.137;
+const J2 = 1.08262668e-3;
+const OMEGA_EARTH_RAD_S = 7.2921159e-5;
+const TWO_PI = Math.PI * 2;
+const KEPLER_TOLERANCE = 1e-10;
+const KEPLER_MAX_ITER = 25;
+const J2000_EPOCH_MS = Date.UTC(2000, 0, 1, 12, 0, 0);
+
+function solveKepler(meanAnomaly, eccentricity) {
+  let m = meanAnomaly % TWO_PI;
+  if (m < 0) {
+    m += TWO_PI;
+  }
+  let eccentricAnomaly = eccentricity < 0.8 ? m : Math.PI;
+  for (let i = 0; i < KEPLER_MAX_ITER; i += 1) {
+    const delta =
+      (eccentricAnomaly - eccentricity * Math.sin(eccentricAnomaly) - m) /
+      (1 - eccentricity * Math.cos(eccentricAnomaly));
+    eccentricAnomaly -= delta;
+    if (Math.abs(delta) < KEPLER_TOLERANCE) {
+      break;
+    }
+  }
+  return eccentricAnomaly;
+}
+
+function j2Rates(elements) {
+  const {
+    semiMajorAxisKm: a,
+    eccentricity: e,
+    inclinationRad: i,
+    meanMotionRadPerSec: n0
+  } = elements;
+  const p = a * (1 - e * e);
+  const factor = 1.5 * n0 * J2 * (R_EARTH_KM / p) ** 2;
+  const cosI = Math.cos(i);
+  const raanDot = -factor * cosI;
+  const argPerigeeDot = 0.5 * factor * (5 * cosI * cosI - 1);
+  const meanAnomalyDot = n0 + 0.5 * factor * Math.sqrt(1 - e * e) * (3 * cosI * cosI - 1);
+  return { raanDot, argPerigeeDot, meanAnomalyDot };
+}
+
+function propagateEci(elements, timestampMs) {
+  const dt = (timestampMs - elements.epochMs) / 1000;
+  const { raanDot, argPerigeeDot, meanAnomalyDot } = j2Rates(elements);
+  const raan = elements.raanRad + raanDot * dt;
+  const argPerigee = elements.argPerigeeRad + argPerigeeDot * dt;
+  const meanAnomaly = elements.meanAnomalyRad + meanAnomalyDot * dt;
+  const e = elements.eccentricity;
+  const a = elements.semiMajorAxisKm;
+
+  const eccentricAnomaly = solveKepler(meanAnomaly, e);
+  const cosE = Math.cos(eccentricAnomaly);
+  const sinE = Math.sin(eccentricAnomaly);
+  const sqrt1MinusE2 = Math.sqrt(1 - e * e);
+  const trueAnomaly = Math.atan2(sqrt1MinusE2 * sinE, cosE - e);
+  const radius = a * (1 - e * cosE);
+
+  const xPerifocal = radius * Math.cos(trueAnomaly);
+  const yPerifocal = radius * Math.sin(trueAnomaly);
+  const meanMotion = Math.sqrt(MU_EARTH_KM3_S2 / (a * a * a));
+  const vxPerifocal = -(a * meanMotion * sinE) / (1 - e * cosE);
+  const vyPerifocal = (a * meanMotion * sqrt1MinusE2 * cosE) / (1 - e * cosE);
+
+  const cosO = Math.cos(raan);
+  const sinO = Math.sin(raan);
+  const cosW = Math.cos(argPerigee);
+  const sinW = Math.sin(argPerigee);
+  const cosI = Math.cos(elements.inclinationRad);
+  const sinI = Math.sin(elements.inclinationRad);
+
+  const r11 = cosO * cosW - sinO * sinW * cosI;
+  const r12 = -cosO * sinW - sinO * cosW * cosI;
+  const r21 = sinO * cosW + cosO * sinW * cosI;
+  const r22 = -sinO * sinW + cosO * cosW * cosI;
+  const r31 = sinW * sinI;
+  const r32 = cosW * sinI;
+
+  return {
+    position: [
+      r11 * xPerifocal + r12 * yPerifocal,
+      r21 * xPerifocal + r22 * yPerifocal,
+      r31 * xPerifocal + r32 * yPerifocal
+    ],
+    velocity: [
+      r11 * vxPerifocal + r12 * vyPerifocal,
+      r21 * vxPerifocal + r22 * vyPerifocal,
+      r31 * vxPerifocal + r32 * vyPerifocal
+    ]
+  };
+}
+
+function gmstRad(timestampMs) {
+  const daysSinceJ2000 = (timestampMs - J2000_EPOCH_MS) / (86400 * 1000);
+  const gmstDeg = (280.46061837 + 360.98564736629 * daysSinceJ2000) % 360;
+  return ((gmstDeg + 360) % 360) * (Math.PI / 180);
+}
+
+function eciToGeodetic(positionKm, timestampMs) {
+  const gmst = gmstRad(timestampMs);
+  const cosG = Math.cos(gmst);
+  const sinG = Math.sin(gmst);
+  const [x, y, z] = positionKm;
+  const xEcef = cosG * x + sinG * y;
+  const yEcef = -sinG * x + cosG * y;
+  const zEcef = z;
+  const radius = Math.sqrt(xEcef * xEcef + yEcef * yEcef + zEcef * zEcef);
+  const latRad = Math.asin(zEcef / radius);
+  const lonRad = Math.atan2(yEcef, xEcef);
+  return {
+    latDeg: (latRad * 180) / Math.PI,
+    lonDeg: (lonRad * 180) / Math.PI,
+    altKm: radius - R_EARTH_KM
+  };
+}
+
+function distanceKm(a, b) {
+  const dx = a[0] - b[0];
+  const dy = a[1] - b[1];
+  const dz = a[2] - b[2];
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+function speedKmS(velocity) {
+  return Math.sqrt(velocity[0] ** 2 + velocity[1] ** 2 + velocity[2] ** 2);
+}
+
+export {
+  distanceKm,
+  eciToGeodetic,
+  gmstRad,
+  J2,
+  MU_EARTH_KM3_S2,
+  OMEGA_EARTH_RAD_S,
+  propagateEci,
+  R_EARTH_KM,
+  solveKepler,
+  speedKmS
+};
diff --git a/src/plugins/conjunctionSSA/propagatorSpec.js b/src/plugins/conjunctionSSA/propagatorSpec.js
new file mode 100644
index 0000000000..f2f662fd96
--- /dev/null
+++ b/src/plugins/conjunctionSSA/propagatorSpec.js
@@ -0,0 +1,76 @@
+import { distanceKm, eciToGeodetic, propagateEci, R_EARTH_KM, solveKepler } from './propagator.js';
+import { parseTle, SEED_TLES } from './tles.js';
+
+describe('propagator', () => {
+  const issTle = SEED_TLES.find((tle) => tle.id === '25544');
+  const issElements = parseTle(issTle.tle1, issTle.tle2);
+
+  describe('solveKepler', () => {
+    it('returns 0 when M is 0', () => {
+      expect(solveKepler(0, 0.01)).toBeCloseTo(0, 10);
+    });
+
+    it('satisfies Kepler equation to high precision', () => {
+      const meanAnomaly = 1.234;
+      const eccentricity = 0.05;
+      const eccentricAnomaly = solveKepler(meanAnomaly, eccentricity);
+      const residual = eccentricAnomaly - eccentricity * Math.sin(eccentricAnomaly) - meanAnomaly;
+      expect(Math.abs(residual)).toBeLessThan(1e-9);
+    });
+  });
+
+  describe('parseTle', () => {
+    it('extracts a plausible LEO semi-major axis for the ISS', () => {
+      expect(issElements.semiMajorAxisKm).toBeGreaterThan(6700);
+      expect(issElements.semiMajorAxisKm).toBeLessThan(6800);
+    });
+
+    it('parses inclination near 51.6 degrees for the ISS', () => {
+      expect((issElements.inclinationRad * 180) / Math.PI).toBeCloseTo(51.6416, 3);
+    });
+  });
+
+  describe('propagateEci', () => {
+    it('produces a position at roughly the semi-major axis magnitude', () => {
+      const state = propagateEci(issElements, issElements.epochMs);
+      const radius = Math.sqrt(
+        state.position[0] ** 2 + state.position[1] ** 2 + state.position[2] ** 2
+      );
+      expect(radius).toBeGreaterThan(issElements.semiMajorAxisKm * 0.99);
+      expect(radius).toBeLessThan(issElements.semiMajorAxisKm * 1.01);
+    });
+
+    it('returns to a nearby position after one full orbital period', () => {
+      const periodSeconds = (2 * Math.PI) / issElements.meanMotionRadPerSec;
+      const stateA = propagateEci(issElements, issElements.epochMs);
+      const stateB = propagateEci(issElements, issElements.epochMs + periodSeconds * 1000);
+      expect(distanceKm(stateA.position, stateB.position)).toBeLessThan(50);
+    });
+  });
+
+  describe('eciToGeodetic', () => {
+    it('produces altitude above the Earth surface for a LEO position', () => {
+      const state = propagateEci(issElements, issElements.epochMs);
+      const geo = eciToGeodetic(state.position, issElements.epochMs);
+      expect(geo.altKm).toBeGreaterThan(300);
+      expect(geo.altKm).toBeLessThan(500);
+      expect(Math.abs(geo.latDeg)).toBeLessThanOrEqual(52);
+    });
+
+    it('produces longitudes in [-180, 180]', () => {
+      const state = propagateEci(issElements, issElements.epochMs + 3600 * 1000);
+      const geo = eciToGeodetic(state.position, issElements.epochMs + 3600 * 1000);
+      expect(geo.lonDeg).toBeGreaterThanOrEqual(-180);
+      expect(geo.lonDeg).toBeLessThanOrEqual(180);
+    });
+
+    it('yields a radius equal to R_EARTH plus altitude', () => {
+      const state = propagateEci(issElements, issElements.epochMs);
+      const geo = eciToGeodetic(state.position, issElements.epochMs);
+      const radius = Math.sqrt(
+        state.position[0] ** 2 + state.position[1] ** 2 + state.position[2] ** 2
+      );
+      expect(radius).toBeCloseTo(R_EARTH_KM + geo.altKm, 6);
+    });
+  });
+});
diff --git a/src/plugins/conjunctionSSA/tles.js b/src/plugins/conjunctionSSA/tles.js
new file mode 100644
index 0000000000..da100a3c5a
--- /dev/null
+++ b/src/plugins/conjunctionSSA/tles.js
@@ -0,0 +1,104 @@
+const SEED_TLES = [
+  {
+    id: '25544',
+    name: 'ISS (ZARYA)',
+    group: 'crewed',
+    tle1: '1 25544U 98067A   24001.50000000  .00016717  00000-0  10270-3 0  9994',
+    tle2: '2 25544  51.6416  85.0000 0002829  30.0000 330.0000 15.50000000    07'
+  },
+  {
+    id: '20580',
+    name: 'HST (HUBBLE)',
+    group: 'science',
+    tle1: '1 20580U 90037B   24001.50000000  .00001234  00000-0  10000-4 0  9990',
+    tle2: '2 20580  28.4696 120.0000 0002707 250.0000 110.0000 15.09000000    05'
+  },
+  {
+    id: '25994',
+    name: 'TERRA',
+    group: 'science',
+    tle1: '1 25994U 99068A   24001.50000000  .00000200  00000-0  50000-4 0  9991',
+    tle2: '2 25994  98.2100  10.0000 0001500  90.0000 270.0000 14.57100000    03'
+  },
+  {
+    id: '27386',
+    name: 'ENVISAT',
+    group: 'debris-large',
+    tle1: '1 27386U 02009A   24001.50000000  .00000050  00000-0  20000-4 0  9992',
+    tle2: '2 27386  98.4000  20.0000 0001200 100.0000 260.0000 14.37800000    01'
+  },
+  {
+    id: '33759',
+    name: 'IRIDIUM 33 DEB',
+    group: 'debris',
+    tle1: '1 33759U 97051X   24001.50000000  .00000100  00000-0  30000-4 0  9993',
+    tle2: '2 33759  86.4000  40.0000 0003000 160.0000 200.0000 14.34000000    02'
+  },
+  {
+    id: '34454',
+    name: 'COSMOS 2251 DEB',
+    group: 'debris',
+    tle1: '1 34454U 93036AAB 24001.50000000  .00000150  00000-0  40000-4 0  9995',
+    tle2: '2 34454  74.0000  60.0000 0005000 140.0000 220.0000 14.20000000    04'
+  },
+  {
+    id: '44714',
+    name: 'STARLINK-1007',
+    group: 'starlink',
+    tle1: '1 44714U 19074A   24001.50000000  .00003000  00000-0  20000-3 0  9996',
+    tle2: '2 44714  53.0500  80.0000 0001500  90.0000 270.0000 15.06000000    06'
+  },
+  {
+    id: '99999',
+    name: 'TEST CHASER (synthetic)',
+    group: 'synthetic',
+    tle1: '1 99999U 24001A   24001.50000000  .00016717  00000-0  10270-3 0  9998',
+    tle2: '2 99999  51.6516  85.0500 0002829  30.0000 330.2000 15.50000000    08'
+  }
+];
+
+const MU_EARTH_KM3_S2 = 398600.4418;
+const SECONDS_PER_DAY = 86400;
+const TWO_PI = Math.PI * 2;
+
+function parseFloatFixed(str) {
+  return Number.parseFloat(str);
+}
+
+function parseEpoch(tle1) {
+  const yy = Number.parseInt(tle1.substring(18, 20), 10);
+  const doy = parseFloatFixed(tle1.substring(20, 32));
+  const year = yy < 57 ? 2000 + yy : 1900 + yy;
+  const jan1 = Date.UTC(year, 0, 1);
+  return jan1 + (doy - 1) * SECONDS_PER_DAY * 1000;
+}
+
+function parseTle(tle1, tle2) {
+  if (!tle1 || !tle2 || tle1.length < 63 || tle2.length < 63) {
+    throw new Error('Invalid TLE line lengths');
+  }
+
+  const epochMs = parseEpoch(tle1);
+  const inclinationDeg = parseFloatFixed(tle2.substring(8, 16));
+  const raanDeg = parseFloatFixed(tle2.substring(17, 25));
+  const eccentricity = parseFloatFixed('0.' + tle2.substring(26, 33).trim());
+  const argPerigeeDeg = parseFloatFixed(tle2.substring(34, 42));
+  const meanAnomalyDeg = parseFloatFixed(tle2.substring(43, 51));
+  const meanMotionRevPerDay = parseFloatFixed(tle2.substring(52, 63));
+
+  const meanMotionRadPerSec = (meanMotionRevPerDay * TWO_PI) / SECONDS_PER_DAY;
+  const semiMajorAxisKm = Math.cbrt(MU_EARTH_KM3_S2 / meanMotionRadPerSec ** 2);
+
+  return {
+    epochMs,
+    inclinationRad: (inclinationDeg * Math.PI) / 180,
+    raanRad: (raanDeg * Math.PI) / 180,
+    eccentricity,
+    argPerigeeRad: (argPerigeeDeg * Math.PI) / 180,
+    meanAnomalyRad: (meanAnomalyDeg * Math.PI) / 180,
+    meanMotionRadPerSec,
+    semiMajorAxisKm
+  };
+}
+
+export { parseTle, SEED_TLES };
diff --git a/src/plugins/plugins.js b/src/plugins/plugins.js
index 938bc51c09..128a651e13 100644
--- a/src/plugins/plugins.js
+++ b/src/plugins/plugins.js
@@ -36,6 +36,7 @@ import Clock from './clock/plugin.js';
 import DerivedTelemetryPlugin from './comps/plugin.js';
 import ConditionPlugin from './condition/plugin.js';
 import ConditionWidgetPlugin from './conditionWidget/plugin.js';
+import ConjunctionSSAPlugin from './conjunctionSSA/plugin.js';
 import CorrelationTelemetryPlugin from './correlationTelemetryPlugin/plugin.js';
 import CouchDBSearchFolder from './CouchDBSearchFolder/plugin.js';
 import DefaultRootName from './defaultRootName/plugin.js';
@@ -158,6 +159,7 @@ plugins.Espresso = Espresso;
 plugins.Snow = Snow;
 plugins.Condition = ConditionPlugin;
 plugins.ConditionWidget = ConditionWidgetPlugin;
+plugins.ConjunctionSSA = ConjunctionSSAPlugin;
 plugins.URLTimeSettingsSynchronizer = URLTimeSettingsSynchronizer;
 plugins.NotificationIndicator = NotificationIndicator;
 plugins.NewFolderAction = NewFolderAction;