gsdd-cli 0.25.0 → 0.27.0

package/bin/lib/global-manifest.mjs

@@ -0,0 +1,122 @@
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { dirname, join, relative, resolve } from 'path';
+
+export const GLOBAL_MANIFEST_FILENAME = 'workspine-file-manifest.json';
+
+export function sha256(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+export function fileHash(filePath) {
+  return sha256(readFileSync(filePath));
+}
+
+export function readGlobalManifest(rootDir) {
+  const manifestPath = join(rootDir, GLOBAL_MANIFEST_FILENAME);
+  if (!existsSync(manifestPath)) return null;
+
+  try {
+    return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeGlobalManifest(rootDir, manifest) {
+  mkdirSync(rootDir, { recursive: true });
+  writeFileSync(join(rootDir, GLOBAL_MANIFEST_FILENAME), JSON.stringify(manifest, null, 2));
+}
+
+export function toManifestPath(rootDir, absolutePath) {
+  return relative(rootDir, absolutePath).replace(/\\/g, '/');
+}
+
+export function writeManifestTrackedFile({
+  rootDir,
+  relativePath,
+  content,
+  previousManifest,
+  nextFiles,
+  dryRun = false,
+}) {
+  const absolutePath = join(rootDir, relativePath);
+  const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+  const expectedHash = sha256(content);
+  const previousHash = previousManifest?.files?.[normalizedRelativePath] || null;
+
+  if (existsSync(absolutePath)) {
+    const currentHash = fileHash(absolutePath);
+    if (currentHash === expectedHash) {
+      nextFiles[normalizedRelativePath] = expectedHash;
+      return { relativePath: normalizedRelativePath, status: 'unchanged' };
+    }
+    if (!previousHash) {
+      return {
+        relativePath: normalizedRelativePath,
+        status: 'skipped_unmanaged',
+        message: 'existing file is not tracked by Workspine manifest',
+      };
+    }
+    if (currentHash !== previousHash) {
+      return {
+        relativePath: normalizedRelativePath,
+        status: 'skipped_modified',
+        message: 'existing Workspine-managed file was modified by the user',
+      };
+    }
+  }
+
+  nextFiles[normalizedRelativePath] = expectedHash;
+  if (!dryRun) {
+    mkdirSync(dirname(absolutePath), { recursive: true });
+    writeFileSync(absolutePath, content);
+  }
+  return { relativePath: normalizedRelativePath, status: dryRun ? 'would_write' : 'written' };
+}
+
+export function pruneStaleManifestTrackedFiles({
+  rootDir,
+  previousManifest,
+  nextFiles,
+  dryRun = false,
+}) {
+  if (!previousManifest?.files) return [];
+
+  const root = resolve(rootDir);
+  const results = [];
+  for (const [relativePath, previousHash] of Object.entries(previousManifest.files)) {
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    if (nextFiles[normalizedRelativePath]) continue;
+
+    const absolutePath = resolve(rootDir, normalizedRelativePath);
+    if (absolutePath !== root && !absolutePath.startsWith(`${root}\\`) && !absolutePath.startsWith(`${root}/`)) {
+      results.push({
+        relativePath: normalizedRelativePath,
+        status: 'skipped_unsafe',
+        message: 'previous manifest path resolves outside the install root',
+      });
+      continue;
+    }
+
+    if (!existsSync(absolutePath)) {
+      results.push({ relativePath: normalizedRelativePath, status: 'removed_missing' });
+      continue;
+    }
+
+    const currentHash = fileHash(absolutePath);
+    if (currentHash !== previousHash) {
+      results.push({
+        relativePath: normalizedRelativePath,
+        status: 'skipped_modified',
+        message: 'stale Workspine-managed file was modified by the user',
+      });
+      continue;
+    }
+
+    if (!dryRun) rmSync(absolutePath, { force: true });
+    results.push({ relativePath: normalizedRelativePath, status: dryRun ? 'would_remove' : 'removed_stale' });
+  }
+
+  return results;
+}

package/bin/lib/health.mjs

@@ -208,11 +208,12 @@ export function buildHealthReport(ctx, healthArgs = []) {
     // W5: Phase dir has PLAN but no SUMMARY (stale in-progress)
     if (lifecycle.incompletePlans.length > 0) {
       for (const plan of lifecycle.incompletePlans) {
+        const expectedSummary = `.planning/phases/${plan.dir}/${plan.baseId}-SUMMARY.md`;
         warnings.push({
           id: 'W5',
           severity: 'WARN',
           message: `${plan.displayPath} exists but no matching SUMMARY found (stale in-progress?)`,
-          fix: 'Resume or complete the phase',
+          fix: `Run \`gsdd execute ${plan.phaseToken}\` to write ${expectedSummary}.`,
         });
       }
     }

package/bin/lib/init-flow.mjs

@@ -320,6 +320,7 @@ function ensureGitignoreEntry(cwd, entry, message) {
 
 function printInitSummary(config) {
   console.log('Config summary:');
+  console.log(`  - rigorProfile: ${config.rigorProfile}`);
   console.log(`  - researchDepth: ${config.researchDepth}`);
   console.log(`  - parallelization: ${config.parallelization}`);
   console.log(`  - commitDocs: ${config.commitDocs}`);
@@ -330,6 +331,8 @@ function printInitSummary(config) {
     console.log(`  - workflow.discuss: ${config.workflow.discuss}`);
     console.log(`  - workflow.planCheck: ${config.workflow.planCheck}`);
     console.log(`  - workflow.verifier: ${config.workflow.verifier}`);
+    console.log(`  - workflow.showCode: ${config.workflow.showCode}`);
+    console.log(`  - workflow.askBeforeDecide: ${config.workflow.askBeforeDecide}`);
   }
   console.log('');
 }

package/bin/lib/init-prompts.mjs

@@ -54,11 +54,12 @@ export async function promptForConfig(cwd, { input = process.stdin, output = pro
   const rigor = await promptSingleSelect({
     input,
     output,
-    title: 'Rigor',
+    title: 'Rigor - how much the assistant does on its own vs. shows you and asks',
     choices: [
-      { value: 'quick', label: 'quick', description: 'Faster setup with lighter planning rigor' },
-      { value: 'balanced', label: 'balanced', description: 'Recommended default for most projects' },
-      { value: 'thorough', label: 'thorough', description: 'Maximum research and plan review rigor' },
+      { value: 'low', label: 'low', description: 'Autopilot. Skips research, plan-check, and asking - it proceeds on its best guess.' },
+      { value: 'medium', label: 'medium', description: 'Recommended default. Research + a fresh-context plan-check. No helpers, no extra asking.' },
+      { value: 'high', label: 'high', description: 'Helpers propose options; shows you the code before writing; asks when something is genuinely unclear.' },
+      { value: 'max', label: 'max', description: 'Most hands-on. Asks before deciding and shows the running screen. Pick low if you just want it to go.' },
     ],
     defaultIndex: 1,
   });
@@ -88,6 +89,7 @@ export async function promptForConfig(cwd, { input = process.stdin, output = pro
   const costConfig = resolveCost(cost);
 
   return {
+    rigorProfile: rigor,
     ...rigorConfig,
     ...costConfig,
     commitDocs,

package/bin/lib/init-runtime.mjs

@@ -172,11 +172,17 @@ Commands:
                               Launch guided install wizard in TTYs, or use --tools for manual/headless setup
                               --auto: non-interactive mode with smart defaults (requires --tools)
                               --brief <file>: copy project brief to .planning/PROJECT_BRIEF.md
+  install --global [--auto] [--tools <platform>] [--dry]
+                              Install reusable Workspine skills and native runtime surfaces into agent home directories
+                              --auto: non-interactive mode that installs detected local agent targets
+                              In TTYs, omitting --tools opens an agent picker
   update [--tools <platform>] [--templates] [--dry]
                               Regenerate adapters from latest framework sources
                               --templates: also refresh .planning/templates/ and roles
                               --dry: preview changes without writing files
   health [--json]             Check workspace integrity (healthy/degraded/broken)
+  next [--json] [--format auto|json|human] [--init]
+                              Read \`.work\` continuity state and emit the next coherent agent action
   models [subcommand]         Inspect or update model profile / runtime overrides
   find-phase [N]              Show phase info as JSON (for agent consumption)
   verify <N>                  Run artifact checks for phase N
@@ -210,19 +216,32 @@ Platforms (for --tools):
   gemini    Generate root AGENTS.md governance block; workflows are already discovered natively from .agents/skills/ (legacy alias kept for backward compatibility)
   all       Generate all adapters (Claude, OpenCode, Codex, AGENTS.md, Cursor, Copilot, Gemini)
 
+Global install targets:
+  claude    Install ~/.claude skills, commands, and agents
+  opencode  Install ~/.agents skills plus ~/.config/opencode commands and agents
+  codex     Install ~/.agents skills plus ~/.codex agents
+  copilot   Install ~/.agents skills plus ~/.copilot agent profiles
+  all       Install all global targets above
+
 Notes:
+  - use \`npx -y gsdd-cli init\` for repo-local setup; use \`npx -y gsdd-cli install --global --auto\` when you want reusable skills in detected agent homes
   - init always generates open-standard skills at .agents/skills/gsdd-*; this is the shared workflow entry surface
   - init also generates a local .planning/bin/gsdd* helper surface for workflow-embedded lifecycle helpers; it is internal/advanced, not the normal first-run user entrypoint
+  - install --global never creates .planning/ in the current repo; it writes only selected agent-home surfaces and per-runtime Workspine manifests
+  - use \`npx -y gsdd-cli install --global --auto\` for non-interactive global install into detected agent homes; use \`--tools <targets>\` to override detection explicitly
+  - repair or refresh a global install by rerunning \`npx -y gsdd-cli install --global --auto\` or \`npx -y gsdd-cli install --global --tools <targets>\`; runtime probes stay in test harnesses
   - Workspine is the public product name; the retained package, command, workflow, and workspace contracts stay gsdd-cli, gsdd, gsdd-*, and .planning/
   - running \`npx -y gsdd-cli init\` in a terminal opens the guided runtime-selection wizard; bare \`gsdd init\` is equivalent only when globally installed
   - the wizard lets you pick runtimes first, then separately decide whether repo-wide AGENTS.md governance is worth installing
-  - \`npx -y gsdd-cli health\` compares any installed generated runtime surfaces against current render output and points back to \`npx -y gsdd-cli update\` when they drift
+  - \`npx -y gsdd-cli health\` is for repo-local .planning/ workspaces; it compares local generated surfaces and points back to \`npx -y gsdd-cli update\` when they drift
+  - \`npx -y gsdd-cli next --init\` bootstraps the local .work continuity surface; plain \`next\` is read-only and emits a typed next-action packet
+  - \`gsdd next\` defaults to JSON when stdout is captured; use \`--format human\` for the compact supervisor card
   - directly validated launch surfaces in this repo are Claude Code, OpenCode, and Codex CLI
   - Cursor, Copilot, and Gemini are qualified support through the shared .agents/skills/ surface plus optional governance
   - --tools remains the advanced/manual path and preserves legacy runtime aliases for backward compatibility
   - --tools codex generates .codex/agents/gsdd-plan-checker.toml (portable skill is the entry surface; $gsdd-plan is plan-only until explicit $gsdd-execute)
   - root AGENTS.md is only written on init when explicitly requested via --tools agents, --tools all, or the wizard governance opt-in
-  - normal user path: npx -y gsdd-cli init -> run /gsdd-* or $gsdd-* -> npx -y gsdd-cli health -> npx -y gsdd-cli update when repair or refresh is needed
+  - normal repo path: npx -y gsdd-cli init -> run /gsdd-* or $gsdd-* -> npx -y gsdd-cli health -> npx -y gsdd-cli update when local repair or refresh is needed
   - post-init, choose your starting lane honestly: new-project for greenfield or fuzzy/milestone work, quick for a concrete bounded change, map-codebase first when the repo needs deeper orientation
 
 Examples:
@@ -238,7 +257,13 @@ Examples:
   npx -y gsdd-cli models clear --runtime opencode --agent plan-checker
   npx -y gsdd-cli init --tools agents
   npx -y gsdd-cli init --tools all
+  npx -y gsdd-cli install --global
+  npx -y gsdd-cli install --global --auto
+  npx -y gsdd-cli install --global --tools claude,opencode,codex,copilot
   npx -y gsdd-cli update
+  npx -y gsdd-cli next --json
+  npx -y gsdd-cli next --format human
+  npx -y gsdd-cli next --init
   npx -y gsdd-cli find-phase
   npx -y gsdd-cli verify 1
   npx -y gsdd-cli control-map annotate set --id canonical --write-set src/app.ts
@@ -273,6 +298,7 @@ Advanced/internal helpers (kept available, but not the primary first-run user st
   ui-proof                  Validate UI proof metadata and compare planned slots to observed bundles
   control-map               Report computed repo/worktree/planning state; annotate only records local intent
   closeout-report           Read-only post-merge closure replay; reports blockers, warnings, and next safe action
+  next                      Read-only \`.work\` continuity router for the next coherent agent action
   file-op                   Deterministic workspace-confined file copy/delete/text mutation
 `;
 }

package/bin/lib/lifecycle-preflight.mjs

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { output } from './cli-utils.mjs';
 import { buildControlMap } from './control-map.mjs';
@@ -76,6 +76,7 @@ const RELEASE_CONTRADICTION_CHECKS = Object.freeze([
 
 const RELEASE_CONTRADICTION_STATUSES = Object.freeze(['passed', 'failed', 'not_applicable']);
 const PREFLIGHT_CONTROL_MAP_SKIP_CODES = Object.freeze(['planning_state_drift']);
+const WORK_PHASE_LINE_RE = /^\s*[-*]\s*\[([ x-])\]\s*\*\*Phase\s+(\d+(?:\.\d+)*[A-Za-z]?):\s*(.+?)\*\*/i;
 
 export function evaluateLifecyclePreflight({
   planningDir,
@@ -95,7 +96,12 @@ export function evaluateLifecyclePreflight({
 
   const lifecycle = evaluateLifecycleState({ planningDir });
   const normalizedPhase = phaseNumber ? normalizePhaseToken(phaseNumber) : null;
+  const workMilestone = normalizedPhase ? evaluateWorkMilestoneState({ planningDir, phaseToken: normalizedPhase }) : null;
   const checkpointPath = join(planningDir, '.continue-here.md');
+  const resumeWorkCheckpoint = surface === 'resume'
+    ? evaluateResumeWorkCheckpoint({ planningDir, checkpointPath })
+    : null;
+  const usesWorkAuthority = Boolean(workMilestone?.phaseEntry || resumeWorkCheckpoint);
   const specPath = join(planningDir, 'SPEC.md');
   const milestonesPath = join(planningDir, 'MILESTONES.md');
   const blockers = [];
@@ -119,7 +125,11 @@ export function evaluateLifecyclePreflight({
   }
 
   if (normalizedPhase) {
-    blockers.push(...buildPhaseBlockers({ lifecycle, phaseToken: normalizedPhase, surface }));
+    blockers.push(
+      ...(usesWorkAuthority
+        ? buildWorkPhaseBlockers({ workMilestone, phaseToken: normalizedPhase, surface })
+        : buildPhaseBlockers({ lifecycle, phaseToken: normalizedPhase, surface }))
+    );
   }
 
   if (surface === 'audit-milestone') {
@@ -176,12 +186,17 @@ export function evaluateLifecyclePreflight({
         details: drift.details,
         files: drift.files,
       };
-      if (policy.classification === 'owned_write') {
+      if (policy.classification === 'owned_write' && !usesWorkAuthority) {
         blockers.push(driftNotice);
       } else {
+        const workWarningContext = resumeWorkCheckpoint
+          ? 'because the checkpoint points at .work/milestone continuity'
+          : `by .work/milestone for Phase ${normalizedPhase}`;
         warnings.push({
           ...driftNotice,
-          message: `Planning state has drifted since the last recorded session: ${drift.details.join('; ')}`,
+          message: usesWorkAuthority
+            ? `Planning state has drifted since the last recorded session, but ${surface} is using work_milestone authority ${workWarningContext}: ${drift.details.join('; ')}`
+            : `Planning state has drifted since the last recorded session: ${drift.details.join('; ')}`,
         });
       }
     }
@@ -198,7 +213,7 @@ export function evaluateLifecyclePreflight({
     else warnings.push(notice);
   }
 
-  if (lifecycle.phaseStatusAlignment.mismatches.length > 0) {
+  if (!usesWorkAuthority && lifecycle.phaseStatusAlignment.mismatches.length > 0) {
     warnings.push({
       code: 'roadmap_phase_status_mismatch',
       message: `ROADMAP.md overview/detail phase statuses disagree: ${lifecycle.phaseStatusAlignment.mismatches.join('; ')}`,
@@ -214,6 +229,7 @@ export function evaluateLifecyclePreflight({
     explicitLifecycleMutation: policy.explicitLifecycleMutation,
     closureEvidence: describeEvidenceSurface(surface),
     mutationRequest: expectsMutation,
+    authority: usesWorkAuthority ? 'work_milestone' : 'planning',
     allowed: blockers.length === 0,
     status: blockers.length === 0 ? 'allowed' : 'blocked',
     reason: blockers[0]?.code ?? null,
@@ -222,10 +238,20 @@ export function evaluateLifecyclePreflight({
     planningState,
     controlMap: controlMap.summary,
     lifecycle: {
+      authority: usesWorkAuthority ? 'work_milestone' : 'planning',
       currentMilestone: lifecycle.currentMilestone,
       currentPhase: lifecycle.currentPhase ? lifecycle.currentPhase.number : null,
       nextPhase: lifecycle.nextPhase ? lifecycle.nextPhase.number : null,
       counts: lifecycle.counts,
+      workMilestone: usesWorkAuthority
+        ? {
+            phase: workMilestone?.phaseEntry?.number ?? null,
+            status: workMilestone?.phaseEntry?.status ?? null,
+            roadmapPath: '.work/milestone/ROADMAP.md',
+            milestoneDir: '.work/milestone',
+            source: resumeWorkCheckpoint ? 'checkpoint' : 'phase',
+          }
+        : null,
     },
   };
 }
@@ -346,6 +372,186 @@ function buildPhaseBlockers({ lifecycle, phaseToken, surface }) {
   return blockers;
 }
 
+function evaluateWorkMilestoneState({ planningDir, phaseToken }) {
+  const workspaceRoot = resolve(planningDir, '..');
+  const milestoneDir = join(workspaceRoot, '.work', 'milestone');
+  const roadmapPath = join(milestoneDir, 'ROADMAP.md');
+  const phasesDir = join(milestoneDir, 'phases');
+
+  if (!existsSync(roadmapPath)) {
+    return null;
+  }
+
+  const phases = parseWorkRoadmapPhases(readFileSync(roadmapPath, 'utf-8'));
+  const phaseEntry = phases.find((phase) => phase.number === phaseToken);
+  if (!phaseEntry) {
+    return null;
+  }
+
+  return {
+    milestoneDir,
+    roadmapPath,
+    phasesDir,
+    phases,
+    phaseEntry,
+    phaseArtifacts: collectWorkPhaseArtifacts({ workspaceRoot, phasesDir, phaseToken }),
+  };
+}
+
+function parseWorkRoadmapPhases(content) {
+  return String(content || '')
+    .replace(/\r\n/g, '\n')
+    .split('\n')
+    .map((line) => {
+      const match = line.match(WORK_PHASE_LINE_RE);
+      if (!match) return null;
+      return {
+        status: parseWorkPhaseStatus(match[1]),
+        number: normalizePhaseToken(match[2]),
+        title: match[3].trim(),
+      };
+    })
+    .filter(Boolean);
+}
+
+function parseWorkPhaseStatus(rawStatus) {
+  const status = String(rawStatus || '').trim().toLowerCase();
+  if (status === 'x') return 'done';
+  if (status === '-') return 'in_progress';
+  return 'pending';
+}
+
+function evaluateResumeWorkCheckpoint({ planningDir, checkpointPath }) {
+  if (!existsSync(checkpointPath)) return null;
+
+  const workspaceRoot = resolve(planningDir, '..');
+  const milestoneDir = join(workspaceRoot, '.work', 'milestone');
+  const roadmapPath = join(milestoneDir, 'ROADMAP.md');
+  if (!existsSync(roadmapPath)) return null;
+
+  let content = '';
+  try {
+    content = readFileSync(checkpointPath, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  if (!/(^|[`"'(\s])\.work[\\/]+milestone([`"')\s/]|$)/i.test(content)) {
+    return null;
+  }
+
+  return {
+    milestoneDir,
+    roadmapPath,
+  };
+}
+
+function collectWorkPhaseArtifacts({ workspaceRoot, phasesDir, phaseToken }) {
+  if (!existsSync(phasesDir)) return [];
+
+  return collectMarkdownFiles(phasesDir)
+    .map((filePath) => {
+      const filename = filePath.split(/[\\/]/).pop();
+      const match = filename.match(/^(\d+(?:\.\d+)*[A-Za-z]?)-(.+?)\.md$/i);
+      if (!match || normalizePhaseToken(match[1]) !== phaseToken) return null;
+
+      const kind = parseWorkArtifactKind(match[2]);
+      if (!kind) return null;
+
+      return {
+        phaseToken,
+        kind,
+        path: filePath,
+        displayPath: relativeDisplayPath(workspaceRoot, filePath),
+      };
+    })
+    .filter(Boolean);
+}
+
+function collectMarkdownFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectMarkdownFiles(fullPath));
+    } else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function parseWorkArtifactKind(rawKind) {
+  const kind = String(rawKind || '').toLowerCase();
+  if (kind === 'plan') return 'plan';
+  if (kind === 'execute') return 'execute';
+  if (kind === 'verify' || kind === 'verification') return 'verification';
+  return null;
+}
+
+function relativeDisplayPath(root, filePath) {
+  return filePath.slice(root.length + 1).replace(/\\/g, '/');
+}
+
+function buildWorkPhaseBlockers({ workMilestone, phaseToken, surface }) {
+  const blockers = [];
+  const planArtifacts = workMilestone.phaseArtifacts.filter((artifact) => artifact.kind === 'plan');
+  const executeArtifacts = workMilestone.phaseArtifacts.filter((artifact) => artifact.kind === 'execute');
+
+  if (surface === 'execute') {
+    if (planArtifacts.length === 0) {
+      blockers.push(
+        blocker(
+          'missing_plan',
+          `Phase ${phaseToken} cannot execute because no .work PLAN artifact exists.`,
+          ['.work/milestone/phases/']
+        )
+      );
+    } else if (executeArtifacts.length > 0) {
+      blockers.push(
+        blocker(
+          'no_pending_plan',
+          `Phase ${phaseToken} has already been executed in .work/milestone.`,
+          executeArtifacts.map((artifact) => artifact.displayPath)
+        )
+      );
+    }
+  }
+
+  if (surface === 'plan' && workMilestone.phaseEntry.status === 'done') {
+    blockers.push(
+      blocker(
+        'phase_already_complete',
+        `Phase ${phaseToken} is already complete in .work/milestone and should not be planned again.`,
+        ['.work/milestone/ROADMAP.md']
+      )
+    );
+  }
+
+  if (surface === 'verify') {
+    if (planArtifacts.length === 0) {
+      blockers.push(
+        blocker(
+          'missing_plan',
+          `Phase ${phaseToken} cannot be verified because no .work PLAN artifact exists.`,
+          ['.work/milestone/phases/']
+        )
+      );
+    }
+    if (executeArtifacts.length === 0) {
+      blockers.push(
+        blocker(
+          'missing_execute',
+          `Phase ${phaseToken} cannot be verified because no .work EXECUTE artifact exists yet.`,
+          ['.work/milestone/phases/']
+        )
+      );
+    }
+  }
+
+  return blockers;
+}
+
 function buildRoadmapAlignmentBlockers(lifecycle) {
   if (lifecycle.phaseStatusAlignment.mismatches.length === 0) return [];
   return [