@tekyzinc/gsd-t 5.2.10 → 5.2.11

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.2.11] - 2026-07-22
+
+### Changed — architect-overview cleanup (dead tool, shared reader, archived contracts)
+
+Applied the three safe findings from a `/gsd-t-architect` framework-overview pass, and recorded a correction to a wrong finding.
+
+- Deleted `bin/model-selector.js` + `test/model-selector.test.js` — the M35 model picker with zero live callers, superseded by M85's `bin/gsd-t-model-tier-policy.cjs`. Scrubbed 3 stale `selectModel()` doc references (`gsd-t-quick.md`, `gsd-t-test-sync.md`, `templates/CLAUDE-project.md`, `README.md`).
+- Extracted a shared marker-block *reader* (`extractMarkedDocBlock`) into `bin/gsd-t-doc-marker.cjs` and rewired `bin/gsd-t-env-registry.cjs::extractBlock` to it — finishing the M102 writer/reader extraction. The verify-gate's independent copy is left intact on purpose (defensive-independence invariant — a writer bug must not disable the gate).
+- Archived 13 stale `mXX-integration-points.md` contracts to `.gsd-t/milestones/_integration-points-archive/`. `m94-integration-points.md` was RESTORED — 3 live M94 tests read it by path (a live fixture, not archaeology).
+
+Recorded in `progress.md`: the overview's "graph subsystem is broken sprawl" finding was a **false negative** — it checked the pre-M99 path `.gsd-t/graph.db`; the real store moved to `.gsd-t/graphDB/graph.db` (M99 consolidation, already shipped, with a canonical resolver). The graph builds and works in every project. No code change — the correction is the deliverable.
+
+Suite: 3020/3020 pass, 13 skipped.
+
 ## [5.2.10] - 2026-07-17
 
 ### Added — Environment Registry (M102): the committed, secret-free connection map

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.2.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.2.11** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.
@@ -18,7 +18,7 @@
 **Rigorous User-Journey Coverage + Anti-Drift Test Quality** — `bin/journey-coverage.cjs` regex listener detector + `gsd-t check-coverage` CLI + `scripts/hooks/pre-commit-journey-coverage` commit gate blocks viewer-source commits when uncovered listeners exist. Journey specs in `e2e/journeys/` use functional assertions (zero `toBeVisible`-only tests) per the E2E Test Quality Standard in CLAUDE.md.
 **Universal Playwright Bootstrap + Deterministic UI Enforcement (M50)** — three executable enforcement layers: (1) `bin/playwright-bootstrap.cjs` + `bin/ui-detection.cjs` - idempotent installer detects package manager, installs `@playwright/test` + chromium, scaffolds `e2e/`; (2) Workflow runtime runs `playwright-bootstrap.cjs::installPlaywright()` before any E2E stage when `hasUI && !hasPlaywright`; install failure halts with `blocked-needs-human`; (3) `scripts/hooks/pre-commit-playwright-gate` (opt-in via `gsd-t doctor --install-hooks`) blocks viewer-source commits when staged files are newer than `.gsd-t/.last-playwright-pass`. The `gsd-t setup-playwright [path]` subcommand handles manual install.
 **Visualizer (`/gsd-t-visualize`)** — launches a real-time browser dashboard with dual-pane view: top pane streams the main session, bottom pane streams whichever spawn the user clicks. Left rail shows Live Spawns and Completed (last 100 spawns, status-badged, collapsible). Right rail shows Spawn Plan / Parallelism / Tool Cost. Powered by `gsd-t-stream-feed-server.js` + `gsd-t-dashboard.html`.
-**Surgical model selection** — `bin/model-selector.js` assigns haiku/sonnet/opus/fable per phase via a declarative rules table; `/advisor` escalation path with convention-based fallback. **M85 single-source tier policy:** `bin/gsd-t-model-tier-policy.cjs` is the SINGLE source of truth for model-tier assignments; the 5 highest-leverage stages (solution-space probe, partition probe, competition judge, pre-mortem, Red Team) run on `fable` (Claude Fable 5, tier above Opus); competition producers stay `opus` (M82 blindness); debug escalates cycle-1→opus, cycle-2→fable. Drift is mechanically enforced by the M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`). **M86 model profiles:** `bin/gsd-t-model-profile.cjs` adds a per-project SECOND dimension — three named profiles (`standard` / `pro` / `premium`) that control which stages run on Fable vs. Opus/Sonnet (see [Model Profiles](#model-profiles) below).
+**Surgical model selection** — models are assigned haiku/sonnet/opus/fable per phase. **M85 single-source tier policy:** `bin/gsd-t-model-tier-policy.cjs` is the SINGLE source of truth for model-tier assignments; the 5 highest-leverage stages (solution-space probe, partition probe, competition judge, pre-mortem, Red Team) run on `fable` (Claude Fable 5, tier above Opus); competition producers stay `opus` (M82 blindness); debug escalates cycle-1→opus, cycle-2→fable. Drift is mechanically enforced by the M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`). **M86 model profiles:** `bin/gsd-t-model-profile.cjs` adds a per-project SECOND dimension — three named profiles (`standard` / `pro` / `premium`) that control which stages run on Fable vs. Opus/Sonnet (see [Model Profiles](#model-profiles) below).
 **Token Telemetry** — `gsd-t-calibration-hook.js` records token usage per spawn to `.gsd-t/token-metrics.jsonl` (18-field rows). `gsd-t-token-aggregator.js` aggregates across tasks for the `/gsd-t-metrics` view. Use the native Claude Code `/context` command for live in-session context percentage.
 **Quality North Star** — projects define a `## Quality North Star` section in CLAUDE.md (1–3 sentences, e.g., "This is a published npm library. Every public API must be intuitive and backward-compatible."). `gsd-t-init` auto-detects preset (library/web-app/cli) from package.json signals; `gsd-t-setup` configures it for existing projects. Subagents read it as a quality lens; absent = silent skip (backward compatible).
 **Design Brief Artifact** — during partition, UI/frontend projects (React, Vue, Svelte, Flutter, Tailwind) automatically get `.gsd-t/contracts/design-brief.md` with color palette, typography, spacing system, component patterns, and tone/voice. Non-UI projects skip silently. User-customized briefs are preserved. Referenced in plan phase for visual consistency.
@@ -466,7 +466,6 @@ get-stuff-done-teams/
 │   ├── graph-*.js                     # Code graph engine (CGC/Neo4j integration)
 │   ├── journey-coverage.cjs           # Listener detector + coverage gap reporting
 │   ├── playwright-bootstrap.cjs       # Idempotent Playwright installer
-│   ├── model-selector.js              # Phase-to-model assignment (haiku/sonnet/opus/fable)
 │   ├── gsd-t-model-tier-policy.cjs    # M85: single-source tier policy (haiku/sonnet/opus/fable), resolver CLI
 │   ├── rule-engine.js                 # Declarative failure-pattern rules
 │   ├── patch-lifecycle.js             # 5-stage patch candidate→graduated lifecycle

package/bin/gsd-t-doc-marker.cjs

@@ -62,4 +62,22 @@ function upsertMarkedDocBlock(targetPath, startMarker, endMarker, block) {
   return targetPath;
 }
 
-module.exports = { upsertMarkedDocBlock };
+// Read the marked block back OUT of `content`. Returns the slice from the START
+// marker up to (but NOT including) the END marker — i.e. the block body a parser
+// walks line-by-line — or null if either marker is absent. The complement of
+// upsertMarkedDocBlock's write. (Shared so a reader isn't re-implemented per
+// caller — the env-registry writer/reader used to copy this inline.)
+//
+// NOTE: the verify GATE (gsd-t-env-registry-check.cjs) deliberately does NOT use
+// this — it re-implements the extract independently so a bug here cannot disable
+// the gate (M102 defensive-independence invariant). That duplication is
+// load-bearing; do not "consolidate" it.
+function extractMarkedDocBlock(content, startMarker, endMarker) {
+  if (typeof content !== "string" || !startMarker || !endMarker) return null;
+  if (!content.includes(startMarker) || !content.includes(endMarker)) return null;
+  const start = content.indexOf(startMarker);
+  const end = content.indexOf(endMarker);
+  return content.slice(start, end);
+}
+
+module.exports = { upsertMarkedDocBlock, extractMarkedDocBlock };

package/bin/gsd-t-env-registry.cjs

@@ -24,7 +24,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { upsertMarkedDocBlock } = require("./gsd-t-doc-marker.cjs");
+const { upsertMarkedDocBlock, extractMarkedDocBlock } = require("./gsd-t-doc-marker.cjs");
 
 // ─── Markers + schema ────────────────────────────────────────────────────────
 
@@ -851,13 +851,11 @@ function infraDocPath(projectDir) {
   return path.join(projectDir, "docs", "infrastructure.md");
 }
 
+// Uses the ONE shared reader from gsd-t-doc-marker.cjs (complement of the shared
+// writer this file already calls) — no inline re-implementation. The verify gate
+// keeps its OWN independent copy on purpose (defensive independence).
 function extractBlock(content) {
-  if (!content.includes(ENV_MARKER_START) || !content.includes(ENV_MARKER_END)) {
-    return null;
-  }
-  const start = content.indexOf(ENV_MARKER_START);
-  const end = content.indexOf(ENV_MARKER_END);
-  return content.slice(start, end);
+  return extractMarkedDocBlock(content, ENV_MARKER_START, ENV_MARKER_END);
 }
 
 function splitRow(line) {

package/commands/gsd-t-quick.md

@@ -25,8 +25,8 @@ Spawn path is `autoSpawnHeadless({command, spawnType, projectDir, sessionContext
 
 Per `.gsd-t/contracts/model-selection-contract.md` v1.0.0.
 
-- **Default**: `sonnet` (`selectModel({phase: "quick"})`) — routine one-off task.
-- **Mechanical subroutines** (demote to `haiku`): test runners (`selectModel({phase: "quick", task_type: "test_runner"})`).
+- **Default**: `sonnet` (per `bin/gsd-t-model-tier-policy.cjs`, phase `quick`) — routine one-off task.
+- **Mechanical subroutines** (demote to `haiku`): test runners.
 - **Red Team (Step 5.5)**: `opus` — adversarial reasoning always runs at top tier.
 - **Escalation**: `/advisor` convention-based fallback from `bin/advisor-integration.js` at declared high-stakes sub-decisions (see `.gsd-t/M35-advisor-findings.md`). Never silently downgrade the model or skip Red Team / doc-ripple under context pressure — M35 removed that behavior.
 

package/commands/gsd-t-test-sync.md

@@ -6,7 +6,7 @@ You are maintaining test coverage as code changes. Your job is to identify stale
 
 Per `.gsd-t/contracts/model-selection-contract.md` v1.0.0.
 
-- **Default**: `sonnet` (`selectModel({phase: "test-sync"})`) — test alignment is routine refactoring work.
+- **Default**: `sonnet` (per `bin/gsd-t-model-tier-policy.cjs`, phase `test-sync`) — test alignment is routine refactoring work.
 - **Escalation**: `/advisor` convention-based fallback from `bin/advisor-integration.js` when a test touches a contract boundary or requires judgment about what "missing coverage" means. Never silently skip test-sync under context pressure — M35 removed that behavior.
 
 This command is:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.2.10",
+  "version": "5.2.11",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/templates/CLAUDE-project.md

@@ -23,7 +23,7 @@ Contract-driven development methodology for Claude Code. npm package providing s
 
 ```
 bin/                     — CLI entry (gsd-t.js) + orchestrators (orchestrator.js, design-orchestrator.js)
-                           + support modules (gsd-t-context-brief.cjs, cli-preflight.cjs, gsd-t-verify-gate.cjs, model-selector.js, …)
+                           + support modules (gsd-t-context-brief.cjs, cli-preflight.cjs, gsd-t-verify-gate.cjs, gsd-t-model-tier-policy.cjs, …)
 commands/                — slash commands for Claude Code (GSD-T workflow + utility)
 templates/               — document + prompt + stack templates
   CLAUDE-{global,project}.md, requirements.md, architecture.md, workflows.md,

package/bin/model-selector.js

@@ -1,234 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * GSD-T Model Selector — surgical per-phase model tier assignment
- *
- * Replaces the v2.x "silent downgrade under context pressure" behavior with
- * declarative per-phase tier assignments. Callers ask `selectModel({phase, ...})`
- * and get back `{model, reason, escalation_hook}` — the tier decision is
- * deterministic, driven by the rules table below, and does NOT depend on
- * session context percentage.
- *
- * Contract: .gsd-t/contracts/model-selection-contract.md v1.0.0 (M35 T4)
- * Findings: .gsd-t/M35-advisor-findings.md (convention-based /advisor fallback)
- *
- * Zero external dependencies.
- */
-
-// ── Tiers ───────────────────────────────────────────────────────────────────
-// M85: FABLE tier added alongside HAIKU/SONNET/OPUS.
-// Contract: .gsd-t/contracts/model-tier-policy-contract.md v1.0.0 § "Stage Policy"
-
-const TIERS = Object.freeze({
-  HAIKU: "haiku",
-  SONNET: "sonnet",
-  OPUS: "opus",
-  FABLE: "fable",
-});
-
-const DEFAULT_TIER = TIERS.SONNET;
-
-// ── Escalation hook block (convention-based /advisor fallback) ──────────────
-//
-// Per `.gsd-t/M35-advisor-findings.md`, Claude Code's native /advisor has no
-// programmable API at subagent scope. This block is injected into the subagent
-// prompt at declared escalation points on sonnet-tier phases where the
-// orchestrator has flagged a high-stakes sub-decision.
-//
-// Kept as a constant so all consumers (command files, advisor-integration.js,
-// M35-advisor-findings.md) reference the same canonical text.
-
-const ESCALATION_HOOK = [
-  "## Escalation Hook — /advisor convention-based fallback",
-  "",
-  "Before finalizing your answer for this phase, stop and consider:",
-  "1. Is this decision high-stakes? (architecture, contract design, security boundary,",
-  "   data-loss risk, cross-module refactor, adversarial QA verdict)",
-  "2. Would a more capable model produce a materially better answer?",
-  "3. Are you confident in the assumptions you're making?",
-  "",
-  "If YES to any of the above, do ONE of the following:",
-  "- Escalate internally: spend an extra reasoning pass re-examining the decision",
-  "  from first principles. Document the re-examination in your output.",
-  "- Spawn a nested opus subagent: use the Task tool with",
-  "  `subagent_type: \"general-purpose\"` and include `model: opus` in the spawn.",
-  "",
-  "Record in your output whether you escalated: set `ESCALATED_VIA_ADVISOR=true` or",
-  "`ESCALATED_VIA_ADVISOR=false` on a line by itself near the end of your report.",
-].join("\n");
-
-// ── Declarative phase rules table ───────────────────────────────────────────
-//
-// Each rule maps (phase, task_type) → tier. The first matching rule wins.
-// `task_type` is optional — when absent, the rule matches any task within
-// that phase. Order the rules from most-specific to least-specific.
-//
-// Tier assignments mirror `.gsd-t/M35-definition.md` Part B and the Model
-// Assignments section of the GSD-T global CLAUDE template:
-//   - haiku:  strictly mechanical — test runners, branch guards, file checks,
-//             JSON validation, no judgment
-//   - sonnet: routine code work — execute step 2, test-sync, doc-ripple wiring,
-//             quick fixes, integration wiring, debug fix-apply
-//   - opus:   high-stakes reasoning — partition, discuss, Red Team, verify
-//             judgment, debug root-cause, contract/architecture design
-
-const PHASE_RULES = Object.freeze([
-  // Phase: execute
-  { phase: "execute", task_type: "test_runner",    model: TIERS.HAIKU,  reason: "Mechanical test-suite runner — zero judgment" },
-  { phase: "execute", task_type: "branch_guard",   model: TIERS.HAIKU,  reason: "Mechanical branch-name check — zero judgment" },
-  { phase: "execute", task_type: "file_check",     model: TIERS.HAIKU,  reason: "Mechanical file-existence check — zero judgment" },
-  { phase: "execute", task_type: "qa",             model: TIERS.SONNET, reason: "QA evaluation needs judgment per M31 tier refinement" },
-  { phase: "execute", task_type: "red_team",       model: TIERS.OPUS,   reason: "Adversarial QA benefits most from top tier" },
-  { phase: "execute",                              model: TIERS.SONNET, reason: "Routine task execution — sonnet is the M35 default for routine work", hasEscalation: true },
-
-  // Phase: wave (the wave orchestrator itself)
-  { phase: "wave",                                 model: TIERS.SONNET, reason: "Wave orchestration dispatches per-phase subagents; the orchestrator itself is routine coordination", hasEscalation: true },
-
-  // Phase: quick
-  { phase: "quick", task_type: "test_runner",      model: TIERS.HAIKU,  reason: "Mechanical test-suite runner — zero judgment" },
-  { phase: "quick",                                model: TIERS.SONNET, reason: "Routine one-off task — sonnet default" },
-
-  // Phase: integrate
-  { phase: "integrate", task_type: "test_runner",  model: TIERS.HAIKU,  reason: "Mechanical integration test runner — zero judgment" },
-  { phase: "integrate",                            model: TIERS.SONNET, reason: "Integration wiring is routine coordination work" },
-
-  // Phase: debug
-  { phase: "debug", task_type: "fix_apply",           model: TIERS.SONNET, reason: "Applying a known fix is routine code work" },
-  { phase: "debug", task_type: "root_cause",          model: TIERS.OPUS,   reason: "Root-cause analysis is high-stakes reasoning" },
-  // M85: cycle-2 escalation — when debug cycle-1 (opus) has not resolved the issue,
-  // cycle-2 escalates to Fable. The debug DEFAULT (cycle-1/general) remains opus —
-  // no existing rule is altered (AC f, no silent degradation). This is a DOCUMENTED
-  // MIRROR for Task-based/bin/ callers; the live enforcement is in the debug workflow
-  // ternary (D3-T3); the D4 lint guards that ternary.
-  // API shape: selectModel({ phase: "debug", task_type: "cycle_2_escalation" }) → fable
-  { phase: "debug", task_type: "cycle_2_escalation",  model: TIERS.FABLE,  reason: "Cycle-2 debug escalation — Fable after opus cycle-1 has not resolved; no existing rule altered (AC f)" },
-  { phase: "debug",                                   model: TIERS.OPUS,   reason: "Debug default is high-stakes — prefer opus unless the task_type says otherwise" },
-
-  // Phase: partition — high-stakes architectural decomposition
-  { phase: "partition",                            model: TIERS.OPUS,   reason: "Domain partitioning is architectural reasoning — high stakes" },
-
-  // Phase: discuss — multi-perspective design exploration
-  { phase: "discuss",                              model: TIERS.OPUS,   reason: "Design exploration benefits from top-tier reasoning" },
-
-  // Phase: plan — task-list authoring
-  { phase: "plan",                                 model: TIERS.SONNET, reason: "Task decomposition is structured work — sonnet with escalation hook", hasEscalation: true },
-
-  // Phase: verify — final quality judgment before milestone complete
-  { phase: "verify",                               model: TIERS.OPUS,   reason: "Milestone verification is the final quality gate — high stakes" },
-
-  // Phase: test-sync — keeping tests aligned with code
-  { phase: "test-sync",                            model: TIERS.SONNET, reason: "Test alignment is routine refactoring work" },
-
-  // Phase: doc-ripple — downstream document updates
-  { phase: "doc-ripple",                           model: TIERS.SONNET, reason: "Documentation updates are routine prose editing" },
-
-  // Phase: red_team — explicit adversarial QA phase (separate from execute task_type)
-  { phase: "red_team",                             model: TIERS.OPUS,   reason: "Adversarial QA — always opus, the incentive is to find bugs" },
-
-  // Phase: qa — explicit standalone QA phase
-  { phase: "qa",                                   model: TIERS.SONNET, reason: "QA per M31 refinement — sonnet produces fewer false negatives than haiku" },
-]);
-
-// Complexity-signal overrides. If the caller provides `complexity_signals`,
-// these can bump a sonnet decision to opus regardless of phase rule.
-const COMPLEXITY_OVERRIDES = Object.freeze({
-  cross_module_refactor: TIERS.OPUS,
-  security_boundary:     TIERS.OPUS,
-  data_loss_risk:        TIERS.OPUS,
-  contract_design:       TIERS.OPUS,
-});
-
-// ── Public API ──────────────────────────────────────────────────────────────
-
-/**
- * Select the model tier for a subagent spawn.
- *
- * @param {object} args
- * @param {string} args.phase           — required; one of the phase names above
- * @param {string} [args.task_type]     — optional task_type for finer-grained rules
- * @param {string} [args.domain_type]   — optional, currently unused (reserved for future per-domain rules)
- * @param {object} [args.complexity_signals] — optional object, keys matching COMPLEXITY_OVERRIDES escalate sonnet→opus
- * @returns {{model: string, reason: string, escalation_hook: string|null}}
- */
-function selectModel(args) {
-  if (!args || typeof args !== "object") {
-    return {
-      model: DEFAULT_TIER,
-      reason: "No args provided — default to routine tier (sonnet)",
-      escalation_hook: null,
-    };
-  }
-
-  const { phase, task_type, complexity_signals } = args;
-
-  if (!phase || typeof phase !== "string") {
-    return {
-      model: DEFAULT_TIER,
-      reason: "No phase provided — default to routine tier (sonnet)",
-      escalation_hook: null,
-    };
-  }
-
-  // First pass: find the most-specific matching rule.
-  let matched = null;
-  for (const rule of PHASE_RULES) {
-    if (rule.phase !== phase) continue;
-    if (rule.task_type && rule.task_type !== task_type) continue;
-    matched = rule;
-    break;
-  }
-
-  if (!matched) {
-    return {
-      model: DEFAULT_TIER,
-      reason: `Unknown phase "${phase}" — fallback to routine tier (sonnet)`,
-      escalation_hook: null,
-    };
-  }
-
-  let model = matched.model;
-  let reason = matched.reason;
-
-  // Complexity-signal overrides: bump sonnet → opus if any flagged signal is truthy.
-  if (model === TIERS.SONNET && complexity_signals && typeof complexity_signals === "object") {
-    for (const key of Object.keys(complexity_signals)) {
-      if (!complexity_signals[key]) continue;
-      const override = COMPLEXITY_OVERRIDES[key];
-      if (override && override !== model) {
-        model = override;
-        reason = `${reason} (escalated to ${override} by complexity signal: ${key})`;
-        break;
-      }
-    }
-  }
-
-  // Escalation hook is only injected on sonnet phases flagged as high-stakes-adjacent.
-  // Haiku phases have no hook (mechanical, no judgment). Opus phases have no hook
-  // (already at top tier — nowhere to escalate).
-  let escalation_hook = null;
-  if (model === TIERS.SONNET && matched.hasEscalation) {
-    escalation_hook = ESCALATION_HOOK;
-  }
-
-  return { model, reason, escalation_hook };
-}
-
-/**
- * Return the canonical list of phase names the selector knows about.
- * Used by tests and documentation tooling to assert coverage.
- */
-function listPhases() {
-  const seen = new Set();
-  for (const rule of PHASE_RULES) seen.add(rule.phase);
-  return [...seen].sort();
-}
-
-module.exports = {
-  selectModel,
-  listPhases,
-  TIERS,
-  DEFAULT_TIER,
-  ESCALATION_HOOK,
-  PHASE_RULES,
-  COMPLEXITY_OVERRIDES,
-};