@agile-vibe-coding/avc 0.2.3 → 0.3.2

package/kanban/client/src/components/ceremony/CeremonyWorkflowModal.jsx

@@ -1,6 +1,8 @@
 import { useState } from 'react';
 import { X, Pencil } from 'lucide-react';
 import { AgentEditorPopup } from '../settings/AgentEditorPopup';
+import { CheckEditorPopup } from '../settings/CheckEditorPopup';
+import { ProviderSwitcherButton } from './ProviderSwitcherButton';
 
 // Human-readable labels for agent slugs
 const AGENT_LABELS = {
@@ -21,8 +23,15 @@ const AGENT_LABELS = {
   'feature-context-generator':            'Feature Context Generator',
   // Sprint Planning
   'epic-story-decomposer':                'Epic/Story Decomposer',
+  'story-scope-reviewer':                 'Story Scope Reviewer',
   'project-context-extractor':            'Project Context Extractor',
   'agent-selector':                       'Agent Selector',
+  'context-writer-epic':                  'Context Writer (Epic)',
+  'context-reviewer-epic':                'Context Reviewer (Epic)',
+  'context-writer-story':                 'Context Writer (Story)',
+  'context-reviewer-story':               'Context Reviewer (Story)',
+  'doc-writer-epic':                      'Doc Writer (Epic)',
+  'doc-writer-story':                     'Doc Writer (Story)',
   'story-doc-enricher':                   'Story Doc Enricher',
   'validator-selector':                   'Validator Selector',
   'validator-epic-solution-architect':    'Solution Architect (Epic)',
@@ -39,40 +48,17 @@ const AGENT_LABELS = {
   'validator-story-backend':              'Backend (Story)',
   'validator-story-frontend':             'Frontend (Story)',
   'validator-story-ux':                   'UX (Story)',
-  // Sprint Planning — Epic Solvers
-  'solver-epic-solution-architect':   'Solver: Solution Architect (Epic)',
-  'solver-epic-developer':            'Solver: Developer (Epic)',
-  'solver-epic-security':             'Solver: Security (Epic)',
-  'solver-epic-devops':               'Solver: DevOps (Epic)',
-  'solver-epic-cloud':                'Solver: Cloud (Epic)',
-  'solver-epic-backend':              'Solver: Backend (Epic)',
-  'solver-epic-database':             'Solver: Database (Epic)',
-  'solver-epic-api':                  'Solver: API (Epic)',
-  'solver-epic-frontend':             'Solver: Frontend (Epic)',
-  'solver-epic-ui':                   'Solver: UI (Epic)',
-  'solver-epic-ux':                   'Solver: UX (Epic)',
-  'solver-epic-mobile':               'Solver: Mobile (Epic)',
-  'solver-epic-data':                 'Solver: Data (Epic)',
-  'solver-epic-qa':                   'Solver: QA (Epic)',
-  'solver-epic-test-architect':       'Solver: Test Architect (Epic)',
-  // Sprint Planning — Story Solvers
-  'solver-story-solution-architect':  'Solver: Solution Architect (Story)',
-  'solver-story-developer':           'Solver: Developer (Story)',
-  'solver-story-security':            'Solver: Security (Story)',
-  'solver-story-devops':              'Solver: DevOps (Story)',
-  'solver-story-cloud':               'Solver: Cloud (Story)',
-  'solver-story-backend':             'Solver: Backend (Story)',
-  'solver-story-database':            'Solver: Database (Story)',
-  'solver-story-api':                 'Solver: API (Story)',
-  'solver-story-frontend':            'Solver: Frontend (Story)',
-  'solver-story-ui':                  'Solver: UI (Story)',
-  'solver-story-ux':                  'Solver: UX (Story)',
-  'solver-story-mobile':              'Solver: Mobile (Story)',
-  'solver-story-data':                'Solver: Data (Story)',
-  'solver-story-qa':                  'Solver: QA (Story)',
-  'solver-story-test-architect':      'Solver: Test Architect (Story)',
+  'story-splitter':                   'Story Splitter',
 };
 
+// ── Domain check perspectives (matching src/cli/checks/{epic|story}/*.json) ──
+
+const DOMAIN_CHECK_PERSPECTIVES = [
+  'solution-architect', 'developer', 'security', 'devops', 'cloud',
+  'backend', 'database', 'api', 'frontend', 'ui', 'ux',
+  'mobile', 'data', 'qa', 'test-architect',
+];
+
 // ── Step type config ──────────────────────────────────────────────────────────
 
 const STEP_TYPE_CONFIG = {
@@ -264,8 +250,6 @@ function buildSponsorCallPhases(ceremony, missionGenValidation) {
 function buildSprintPlanningPhases(ceremony) {
   // Stages that aren't explicitly configured fall back to ceremony.defaultModel
   const fallbackModel = ceremony.defaultModel;
-  const solverMaxIter  = ceremony.stages?.solver?.maxIterations   ?? 3;
-  const solverThreshold = ceremony.stages?.solver?.acceptanceThreshold ?? 95;
 
   return [
     {
@@ -296,15 +280,51 @@ function buildSprintPlanningPhases(ceremony) {
             { name: 'project/doc.md', direction: 'in', note: 'scope text extracted from doc.md' },
           ],
         },
+        {
+          type:       'generate',
+          label:      'Detect semantic duplicates among new epics and against existing on-disk epics — merge overlapping items automatically',
+          model:      ceremony.stages?.decomposition?.model ?? fallbackModel,
+          stageKey:   'decomposition',
+          sharedWith: 'Decomposer',
+          agent:      'duplicate-detector',
+        },
+        {
+          type:       'process',
+          label:      'Review each Epic\'s stories and split any that mix too many concerns (one LLM call per Epic in parallel)',
+          model:      ceremony.stages?.decomposition?.model ?? fallbackModel,
+          stageKey:   'decomposition',
+          sharedWith: 'Decomposer',
+          agent:      'story-scope-reviewer',
+        },
+      ],
+    },
+    {
+      id: 'context-generation',
+      label: 'Context Generation',
+      color: 'violet',
+      steps: [
+        {
+          type:     'generate',
+          label:    'Write + independently review each Epic/Story context.md (Write → Review → Refine, up to 3 rounds per item)',
+          model:    ceremony.stages?.['context-generation']?.model ?? fallbackModel,
+          stageKey: 'context-generation',
+          agents: [
+            { slug: 'context-writer-epic',   note: 'writes epic context.md' },
+            { slug: 'context-reviewer-epic',  note: 'audits epic context against source JSON' },
+            { slug: 'context-writer-story',   note: 'writes story context.md' },
+            { slug: 'context-reviewer-story', note: 'audits story context against source JSON' },
+          ],
+          files: [
+            { name: '{epic}/context.md',  direction: 'out' },
+            { name: '{story}/context.md', direction: 'out' },
+          ],
+        },
       ],
     },
     {
       id: 'validation',
-      label: 'Multi-Agent Validation (Iterative)',
+      label: 'Micro-Check Validation (3-Tier)',
       color: 'amber',
-      // Per-validator iteration loop: each validator runs, if issues found a paired
-      // solver improves the epic/story, then the same validator re-validates.
-      // Validators run sequentially so each one sees improvements from previous pairs.
       steps: [
         {
           type:     'generate',
@@ -322,74 +342,49 @@ function buildSprintPlanningPhases(ceremony) {
           agent:      'agent-selector',
         },
         {
-          type:          'loop-group',
-          loopParamType: 'sprintSolver',
-          loop: {
-            max:       solverMaxIter,
-            threshold: solverThreshold,
-          },
-          steps: [
-            {
-              type:     'validate',
-              label:    'Validate each Epic with domain expert validators (sequential)',
-              model:    ceremony.stages?.validation?.model ?? fallbackModel,
-              stageKey: 'validation',
-              agents: [
-                { slug: 'validator-epic-solution-architect', note: 'always runs' },
-                { slug: 'validator-epic-developer',          note: 'always runs' },
-                { slug: 'validator-epic-security',           note: 'always runs' },
-                { slug: 'validator-epic-backend',            note: '+ domain validators selected per project' },
-              ],
-            },
-            {
-              type:     'refine',
-              label:    'Solve issues — improve Epic description, features, dependencies',
-              model:    ceremony.stages?.solver?.model ?? fallbackModel,
-              stageKey: 'solver',
-              agents: [
-                { slug: 'solver-epic-solution-architect', note: 'paired with validator-epic-solution-architect' },
-                { slug: 'solver-epic-developer',          note: 'paired with validator-epic-developer' },
-                { slug: 'solver-epic-security',           note: 'paired with validator-epic-security' },
-                { slug: 'solver-epic-backend',            note: 'paired with each domain validator' },
-              ],
-            },
+          type:     'validate',
+          label:    'Tier 1: Run domain checks per perspective — each check is 1-2 YES/NO LLM calls, run in parallel',
+          model:    ceremony.stages?.validation?.model ?? fallbackModel,
+          stageKey: 'validation',
+          sharedWith: 'Validation',
+          params: [
+            { key: 'concurrency', label: 'Parallel checks', value: ceremony.stages?.validation?.concurrency ?? 5, min: 1, max: 20 },
+            { key: 'batchSize', label: 'Checks per batch', value: ceremony.stages?.validation?.batchSize ?? 8, min: 1, max: 20 },
           ],
+          checks: DOMAIN_CHECK_PERSPECTIVES.flatMap(p => [
+            { scope: 'epic',  perspective: p, label: `${p} (Epic)` },
+            { scope: 'story', perspective: p, label: `${p} (Story)` },
+          ]),
         },
         {
-          type:          'loop-group',
-          loopParamType: 'sprintSolver',
-          loopParamReadOnly: true,
-          loop: {
-            max:       solverMaxIter,
-            threshold: solverThreshold,
-          },
-          steps: [
-            {
-              type:     'validate',
-              label:    'Validate each Story with domain expert validators (sequential)',
-              model:    ceremony.stages?.validation?.model ?? fallbackModel,
-              stageKey: 'validation',
-              agents: [
-                { slug: 'validator-story-developer',      note: 'always runs' },
-                { slug: 'validator-story-qa',             note: 'always runs' },
-                { slug: 'validator-story-test-architect', note: 'always runs' },
-                { slug: 'validator-story-backend',        note: '+ domain validators selected per project' },
-              ],
-            },
-            {
-              type:     'refine',
-              label:    'Solve issues — improve Story description, acceptance criteria, dependencies',
-              model:    ceremony.stages?.solver?.model ?? fallbackModel,
-              stageKey: 'solver',
-              agents: [
-                { slug: 'solver-story-developer',      note: 'paired with validator-story-developer' },
-                { slug: 'solver-story-qa',             note: 'paired with validator-story-qa' },
-                { slug: 'solver-story-test-architect', note: 'paired with validator-story-test-architect' },
-                { slug: 'solver-story-backend',        note: 'paired with each domain validator' },
-              ],
-            },
+          type:       'cross',
+          label:      'Tier 2: Cross-reference consistency checks — verify perspectives agree (e.g., security \u2194 API, database \u2194 architecture). Runs after Tier 1 using evidence from domain checks.',
+          model:      ceremony.stages?.validation?.model ?? fallbackModel,
+          stageKey:   'validation',
+          sharedWith: 'Validation',
+          checks: [
+            { scope: 'cross-refs', perspective: 'epic',  label: 'Epic Cross-Refs' },
+            { scope: 'cross-refs', perspective: 'story', label: 'Story Cross-Refs' },
+          ],
+        },
+        {
+          type:       'refine',
+          label:      'Tier 3: Deterministic scoring + auto-fix critical/major failures (atomic per-check fixes with regression revert)',
+          model:      ceremony.stages?.validation?.model ?? fallbackModel,
+          stageKey:   'validation',
+          sharedWith: 'Validation',
+          params: [
+            { key: 'maxFixAttempts', label: 'Max fix attempts', value: ceremony.stages?.validation?.maxFixAttempts ?? 3, min: 0, max: 10 },
           ],
         },
+        {
+          type:       'process',
+          label:      'If story still below threshold with 15+ ACs and scope issues detected: split into 2-3 focused stories, replace in epic, and re-validate each split story',
+          model:      ceremony.stages?.validation?.model ?? fallbackModel,
+          stageKey:   'validation',
+          sharedWith: 'Validation',
+          agent:      'story-splitter',
+        },
       ],
     },
     {
@@ -397,27 +392,29 @@ function buildSprintPlanningPhases(ceremony) {
       label: 'Documentation & Output',
       color: 'emerald',
       steps: [
-        { type: 'process', label: 'Renumber hierarchy IDs' },
+        { type: 'process', label: 'Renumber hierarchy IDs + write context.md files with final IDs' },
         {
           type:     'generate',
-          label:    'Distribute documentation — extract Epic-specific content from project/doc.md into each Epic\'s doc.md (moves content, doesn\'t copy)',
-          model:    ceremony.stages?.['doc-distribution']?.model ?? fallbackModel,
-          stageKey: 'doc-distribution',
-          agent:    'doc-distributor',
+          label:    'Generate narrative doc.md for each Epic from its canonical context.md',
+          model:    ceremony.stages?.['doc-generation']?.model ?? fallbackModel,
+          stageKey: 'doc-generation',
+          agent:    'doc-writer-epic',
           files:    [
-            { name: 'project/doc.md',  direction: 'in',  note: 'source — progressively lightened as epics extract their content' },
-            { name: '{epic}/doc.md',   direction: 'out', note: 'receives content extracted from project doc' },
+            { name: 'project/doc.md',  direction: 'in',  note: 'project context' },
+            { name: '{epic}/context.md', direction: 'in', note: 'canonical spec — single source of truth' },
+            { name: '{epic}/doc.md',   direction: 'out', note: 'narrative documentation' },
           ],
         },
         {
           type:     'generate',
-          label:    'Distribute documentation — extract Story-specific content from each Epic\'s doc.md into each Story\'s doc.md',
-          model:    ceremony.stages?.['doc-distribution']?.model ?? fallbackModel,
-          stageKey: 'doc-distribution',
-          agent:    'doc-distributor',
+          label:    'Generate narrative doc.md for each Story from its canonical context.md',
+          model:    ceremony.stages?.['doc-generation']?.model ?? fallbackModel,
+          stageKey: 'doc-generation',
+          agent:    'doc-writer-story',
           files:    [
-            { name: '{epic}/doc.md',   direction: 'in',  note: 'source — progressively lightened as stories extract their content' },
-            { name: '{story}/doc.md',  direction: 'out', note: 'receives content extracted from epic doc' },
+            { name: '{epic}/context.md',  direction: 'in',  note: 'parent epic context' },
+            { name: '{story}/context.md', direction: 'in',  note: 'canonical spec — single source of truth' },
+            { name: '{story}/doc.md',     direction: 'out', note: 'narrative documentation' },
           ],
         },
         {
@@ -442,12 +439,113 @@ function buildSprintPlanningPhases(ceremony) {
     },
   ];
 }
-function buildSeedPhases(_c)           { return null; }
+function buildSeedPhases(c) {
+  return [
+    {
+      id: 'decompose',
+      label: 'Decompose Story',
+      color: 'blue',
+      steps: [
+        {
+          type:     'read',
+          label:    'Read story, epic, and project context',
+        },
+        {
+          type:     'generate',
+          label:    'Decompose story into tasks and subtasks',
+          model:    c?.stages?.decomposition?.model,
+          stageKey: 'decomposition',
+          agent:    'task-subtask-decomposer',
+        },
+        {
+          type:     'process',
+          label:    'Validate task/subtask structure and IDs (deterministic)',
+        },
+      ],
+    },
+    {
+      id: 'context-gen',
+      label: 'Task Documentation',
+      color: 'green',
+      steps: [
+        {
+          type:     'generate',
+          label:    'Generate context.md for each task and subtask',
+          model:    c?.stages?.['context-generation']?.model,
+          stageKey: 'context-generation',
+        },
+        {
+          type:     'output',
+          label:    'Write work.json, context.md, and doc.md files',
+        },
+      ],
+    },
+  ];
+}
+
+function buildRunPhases(c) {
+  return [
+    {
+      id: 'implement',
+      label: 'Code Generation',
+      color: 'blue',
+      steps: [
+        {
+          type:     'read',
+          label:    'Create git worktree and read documentation chain',
+        },
+        {
+          type:     'generate',
+          label:    'AI generates code following traceability rules',
+          model:    c?.stages?.['code-generation']?.model,
+          stageKey: 'code-generation',
+          agent:    'code-implementer',
+        },
+      ],
+    },
+    {
+      id: 'validate',
+      label: 'Code Validation',
+      color: 'amber',
+      steps: [
+        {
+          type:     'validate',
+          label:    'Verify code against quality and traceability checks',
+          model:    c?.stages?.['code-validation']?.model,
+          stageKey: 'code-validation',
+          agent:    'code-validator',
+        },
+        {
+          type:     'generate',
+          label:    'Fix violations and regenerate (if needed, up to 3 iterations)',
+          model:    c?.stages?.['code-generation']?.model,
+          stageKey: 'code-generation',
+        },
+      ],
+    },
+    {
+      id: 'test-merge',
+      label: 'Test & Merge',
+      color: 'green',
+      steps: [
+        {
+          type:     'validate',
+          label:    'Run tests in worktree',
+        },
+        {
+          type:     'output',
+          label:    'Commit, merge to main, update function registry',
+        },
+      ],
+    },
+  ];
+}
 
 const CEREMONY_WORKFLOWS = {
   'sponsor-call':    buildSponsorCallPhases,
   'sprint-planning': (c) => buildSprintPlanningPhases(c),
-  'seed':            (_c) => buildSeedPhases(_c),
+  'seed':            (c) => buildSeedPhases(c),
+  'run':             (c) => buildRunPhases(c),
 };
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -521,6 +619,33 @@ function AgentLinks({ step, onOpenAgent }) {
   );
 }
 
+// ── Check links ──────────────────────────────────────────────────────────────
+// Renders clickable check-definition badges inside a scrollable container.
+
+function CheckLinks({ step, onOpenCheck }) {
+  if (!step.checks || step.checks.length === 0) return null;
+
+  return (
+    <div className="mt-1.5">
+      <span className="text-[10px] text-slate-400 font-medium">Check definitions</span>
+      <div className="mt-1 max-h-28 overflow-y-auto border border-slate-100 rounded-md px-1.5 py-1 flex flex-wrap gap-1">
+        {step.checks.map((c) => (
+          <button
+            key={`${c.scope}/${c.perspective}`}
+            type="button"
+            onClick={() => onOpenCheck({ scope: c.scope, perspective: c.perspective })}
+            className="inline-flex items-center gap-1 text-[10px] font-medium text-amber-700 hover:text-amber-900 bg-amber-50 hover:bg-amber-100 border border-amber-200 hover:border-amber-300 px-1.5 py-0.5 rounded transition-colors whitespace-nowrap"
+            title={`Edit ${c.scope}/${c.perspective}.json`}
+          >
+            {c.label}
+            <Pencil className="w-2.5 h-2.5 flex-shrink-0" />
+          </button>
+        ))}
+      </div>
+    </div>
+  );
+}
+
 // ── File tags ─────────────────────────────────────────────────────────────────
 // Renders small ← filename (input) / → filename (output) badges on step cards.
 // Steps can carry a `files` array: [{ name, direction: 'in'|'out', note? }]
@@ -566,7 +691,7 @@ function StepBadge({ type }) {
 
 // ── Plain step card ───────────────────────────────────────────────────────────
 
-function StepCard({ step, models, editable, onStageModelChange, onValidationModelChange, onOpenAgent }) {
+function StepCard({ step, models, editable, onStageModelChange, onValidationModelChange, onStageParamChange, onOpenAgent, onOpenCheck }) {
   const showModel = !['input', 'output', 'read', 'process'].includes(step.type);
   const canEdit   = editable && !step.sharedWith && (step.stageKey || step.validationKey);
 
@@ -604,14 +729,39 @@ function StepCard({ step, models, editable, onStageModelChange, onValidationMode
 
       <div className="pl-1">
         <AgentLinks step={step} onOpenAgent={onOpenAgent} />
+        {onOpenCheck && <CheckLinks step={step} onOpenCheck={onOpenCheck} />}
       </div>
+
+      {/* Inline params (e.g. concurrency, maxFixAttempts) */}
+      {step.params && step.params.length > 0 && (
+        <div className="mt-2 pl-1 flex items-center gap-3 flex-wrap">
+          {step.params.map((p) => (
+            <label key={p.key} className="flex items-center gap-1.5 text-[11px] text-slate-600">
+              <span className="font-medium">{p.label}:</span>
+              {editable && step.stageKey && onStageParamChange ? (
+                <input
+                  type="number"
+                  min={p.min}
+                  max={p.max}
+                  value={p.value}
+                  onChange={(e) => onStageParamChange(step.stageKey, p.key, Number(e.target.value))}
+                  onClick={(e) => e.stopPropagation()}
+                  className="w-12 text-xs border border-slate-300 rounded px-1.5 py-0.5 bg-white text-slate-800 text-center focus:outline-none focus:ring-1 focus:ring-blue-400"
+                />
+              ) : (
+                <span className="font-mono">{p.value}</span>
+              )}
+            </label>
+          ))}
+        </div>
+      )}
     </div>
   );
 }
 
 // ── Loop group card ───────────────────────────────────────────────────────────
 
-function LoopGroupCard({ group, models, editable, onStageModelChange, onValidationModelChange, onLoopParamChange, onOpenAgent }) {
+function LoopGroupCard({ group, models, editable, onStageModelChange, onValidationModelChange, onStageParamChange, onLoopParamChange, onOpenAgent, onOpenCheck }) {
   const { loop, steps }   = group;
   const isIndigo          = steps.some((s) => s.type === 'cross');
   const c                 = isIndigo ? LOOP_C.indigo : LOOP_C.amber;
@@ -677,7 +827,9 @@ function LoopGroupCard({ group, models, editable, onStageModelChange, onValidati
                 editable={editable}
                 onStageModelChange={onStageModelChange}
                 onValidationModelChange={onValidationModelChange}
+                onStageParamChange={onStageParamChange}
                 onOpenAgent={onOpenAgent}
+                onOpenCheck={onOpenCheck}
               />
               {i < steps.length - 1 && (
                 <div className="flex items-center gap-2 my-1.5 ml-3">
@@ -729,10 +881,13 @@ function Connector() {
 
 export function CeremonyWorkflowModal({
   ceremony,
+  allCeremonies,
+  apiKeys,
   models = [],
   missionGenValidation = null,
   onClose,
   onSave,
+  onCeremoniesUpdated,
   readOnly = false,
 }) {
   const [draft, setDraft] = useState(() => JSON.parse(JSON.stringify(ceremony || {})));
@@ -742,6 +897,7 @@ export function CeremonyWorkflowModal({
   const [saving, setSaving] = useState(false);
   const [saveError, setSaveError] = useState(null);
   const [openAgentSlug, setOpenAgentSlug] = useState(null);
+  const [openCheck, setOpenCheck] = useState(null); // { scope, perspective } | null
 
   // Phases rebuild from draft every render — always reflect current edits
   const buildPhases = ceremony?.name ? CEREMONY_WORKFLOWS[ceremony.name] : null;
@@ -792,19 +948,24 @@ export function CeremonyWorkflowModal({
     }
   };
 
+  const updateStageParam = (stageKey, paramKey, value) => {
+    setDraft((prev) => ({
+      ...prev,
+      stages: {
+        ...prev.stages,
+        [stageKey]: {
+          ...prev.stages?.[stageKey],
+          [paramKey]: value,
+        },
+      },
+    }));
+  };
+
   const updateLoopParam = (loopParamType, field, value) => {
     if (loopParamType === 'missionGen') {
       setMissionGenDraft((prev) => ({ ...prev, [field]: value }));
     } else if (loopParamType === 'docContext') {
       setDraft((prev) => ({ ...prev, validation: { ...prev.validation, [field]: value } }));
-    } else if (loopParamType === 'sprintSolver') {
-      setDraft((prev) => ({
-        ...prev,
-        stages: {
-          ...prev.stages,
-          solver: { ...(prev.stages?.solver || {}), [field]: value },
-        },
-      }));
     }
   };
 
@@ -851,13 +1012,27 @@ export function CeremonyWorkflowModal({
               {ceremony?.displayName || ceremony?.name || 'Unknown ceremony'}
             </p>
           </div>
-          <button
-            type="button"
-            onClick={isEditable ? handleCancel : onClose}
-            className="text-slate-400 hover:text-slate-600 transition-colors"
-          >
-            <X className="w-4 h-4" />
-          </button>
+          <div className="flex items-center gap-2">
+            {isEditable && allCeremonies && (
+              <ProviderSwitcherButton
+                ceremonyName={ceremony?.name}
+                ceremonies={allCeremonies.map((c) => c.name === ceremony?.name ? draft : c)}
+                apiKeys={apiKeys}
+                onApplied={(updated) => {
+                  const updatedCeremony = updated.find((c) => c.name === ceremony?.name);
+                  if (updatedCeremony) setDraft(JSON.parse(JSON.stringify(updatedCeremony)));
+                  onCeremoniesUpdated?.(updated);
+                }}
+              />
+            )}
+            <button
+              type="button"
+              onClick={isEditable ? handleCancel : onClose}
+              className="text-slate-400 hover:text-slate-600 transition-colors"
+            >
+              <X className="w-4 h-4" />
+            </button>
+          </div>
         </div>
 
         {/* Scrollable body */}
@@ -879,8 +1054,10 @@ export function CeremonyWorkflowModal({
                         editable={isEditable}
                         onStageModelChange={updateStageModel}
                         onValidationModelChange={updateValidationModel}
+                        onStageParamChange={updateStageParam}
                         onLoopParamChange={updateLoopParam}
                         onOpenAgent={setOpenAgentSlug}
+                        onOpenCheck={setOpenCheck}
                       />
                     ) : (
                       <StepCard
@@ -889,7 +1066,9 @@ export function CeremonyWorkflowModal({
                         editable={isEditable}
                         onStageModelChange={updateStageModel}
                         onValidationModelChange={updateValidationModel}
+                        onStageParamChange={updateStageParam}
                         onOpenAgent={setOpenAgentSlug}
+                        onOpenCheck={setOpenCheck}
                       />
                     )}
                     {si < phase.steps.length - 1 && <Connector />}
@@ -941,6 +1120,14 @@ export function CeremonyWorkflowModal({
           onClose={() => setOpenAgentSlug(null)}
         />
       )}
+
+      {openCheck && (
+        <CheckEditorPopup
+          scope={openCheck.scope}
+          perspective={openCheck.perspective}
+          onClose={() => setOpenCheck(null)}
+        />
+      )}
     </div>
   );
 }