universal-dev-standards 5.0.0-rc.8 → 5.0.0

package/src/commands/update.js

@@ -9,7 +9,8 @@ import { getRepositoryInfo, getAllStandards, getStandardSource } from '../utils/
 import { computeFileHash, scanForUntrackedFiles, refreshIntegrationBlockHashes } from '../utils/hasher.js';
 import {
   writeIntegrationFile,
-  getToolFilePath
+  getToolFilePath,
+  writeAgentsMdSummary
 } from '../utils/integration-generator.js';
 import {
   calculateCategoriesFromStandards,
@@ -45,6 +46,34 @@ import {
   formatPlan,
   listBackups
 } from '../reconciler/index.js';
+import { restoreSingleFile } from './check.js';
+
+/**
+ * Determine the correct target directory for a standard file.
+ * Options standards (e.g., options/unit-testing.ai.yaml) go to .standards/options/,
+ * all others go to .standards/.
+ */
+function getStandardTargetDir(sourcePath) {
+  return sourcePath.includes('options/') ? '.standards/options' : '.standards';
+}
+
+/**
+ * Clean up stale commandHashes entries before merging new ones.
+ * Removes old entries for agents that are being updated.
+ */
+function replaceCommandHashesForUpdatedAgents(commandHashes, newHashes) {
+  const updatedPrefixes = new Set(
+    Object.keys(newHashes).map(k => k.split('/')[0])
+  );
+  for (const prefix of updatedPrefixes) {
+    for (const key of Object.keys(commandHashes)) {
+      if (key.startsWith(prefix + '/')) {
+        delete commandHashes[key];
+      }
+    }
+  }
+  Object.assign(commandHashes, newHashes);
+}
 
 /**
  * Compare two semantic versions
@@ -331,11 +360,15 @@ export async function updateCommand(options) {
   // List files to update
   console.log(chalk.gray(msg.filesToUpdate));
   for (const std of manifest.standards) {
-    console.log(chalk.gray(`  .standards/${std.split('/').pop()}`));
+    const fileName = std.split('/').pop();
+    const displayPath = getStandardTargetDir(std) + '/' + fileName;
+    console.log(chalk.gray(`  ${displayPath}`));
   }
   for (const ext of manifest.extensions) {
     if (typeof ext !== 'string') continue;
-    console.log(chalk.gray(`  .standards/${ext.split('/').pop()}`));
+    const fileName = ext.split('/').pop();
+    const displayPath = getStandardTargetDir(ext) + '/' + fileName;
+    console.log(chalk.gray(`  ${displayPath}`));
   }
   if (!options.standardsOnly) {
     for (const int of manifest.integrations) {
@@ -382,7 +415,7 @@ export async function updateCommand(options) {
 
   // Update standards
   for (const std of manifest.standards) {
-    const result = await copyStandard(std, '.standards', projectPath);
+    const result = await copyStandard(std, getStandardTargetDir(std), projectPath);
     if (result.success) {
       results.updated.push(std);
     } else {
@@ -428,7 +461,7 @@ export async function updateCommand(options) {
       let newCount = 0;
 
       for (const ns of newStandards) {
-        const result = await copyStandard(ns.source, '.standards', projectPath);
+        const result = await copyStandard(ns.source, getStandardTargetDir(ns.source), projectPath);
         if (result.success) {
           manifest.standards.push(ns.source);
           results.updated.push(ns.source);
@@ -495,6 +528,27 @@ export async function updateCommand(options) {
       }
     }
 
+    // Update universal AGENTS.md if enabled and not already generated by tool integration
+    if (manifest.generateAgentsMd && !generatedFiles.has('AGENTS.md')) {
+      const summaryConfig = {
+        installedStandards: installedStandardsList,
+        language: manifest.options?.display_language || 'en',
+        commitLanguage: manifest.options?.commit_language || 'english',
+        standardOptions: manifest.options || {}
+      };
+      const agentsMdResult = writeAgentsMdSummary(summaryConfig, projectPath);
+      if (agentsMdResult.success) {
+        results.integrations.push(agentsMdResult.path);
+        if (agentsMdResult.blockHashInfo) {
+          if (!manifest.integrationBlockHashes) manifest.integrationBlockHashes = {};
+          manifest.integrationBlockHashes[agentsMdResult.path] = {
+            ...agentsMdResult.blockHashInfo,
+            installedAt: new Date().toISOString()
+          };
+        }
+      }
+    }
+
     intSpinner.succeed(msg.syncedIntegrations.replace('{count}', results.integrations.length));
   }
 
@@ -507,9 +561,9 @@ export async function updateCommand(options) {
   // Update hashes for standards
   for (const std of manifest.standards) {
     const fileName = basename(std);
-    const relativePath = std.includes('options/')
+    const relativePath = (std.includes('options/')
       ? join('.standards', 'options', fileName)
-      : join('.standards', fileName);
+      : join('.standards', fileName)).replace(/\\/g, '/');
     const fullPath = join(projectPath, relativePath);
     const hashInfo = computeFileHash(fullPath);
     if (hashInfo) {
@@ -521,7 +575,7 @@ export async function updateCommand(options) {
   for (const ext of manifest.extensions) {
     if (typeof ext !== 'string') continue;
     const fileName = basename(ext);
-    const relativePath = join('.standards', fileName);
+    const relativePath = join('.standards', fileName).replace(/\\/g, '/');
     const fullPath = join(projectPath, relativePath);
     const hashInfo = computeFileHash(fullPath);
     if (hashInfo) {
@@ -553,6 +607,27 @@ export async function updateCommand(options) {
     }
   }
 
+  // Migrate test_levels: upgrade old 2-level default to full 4-level default
+  // Only for projects installed before v5.0.0 stable (pre-5.0 used 2-level default)
+  // 5.0.0-alpha/beta/rc are also < 5.0.0 in semver, so they get migrated too
+  const installedVersion = currentVersion || '0.0.0';
+  const isPreV5 = compareVersions(installedVersion, '5.0.0') < 0;
+  if (isPreV5) {
+    const ALL_TEST_LEVELS = ['unit-testing', 'integration-testing', 'system-testing', 'e2e-testing'];
+    const currentLevels = manifest.options?.test_levels || [];
+    const isOldDefault = currentLevels.length === 2 &&
+      currentLevels.includes('unit-testing') &&
+      currentLevels.includes('integration-testing') &&
+      !currentLevels.includes('system-testing') &&
+      !currentLevels.includes('e2e-testing');
+    if (isOldDefault) {
+      manifest.options = manifest.options || {};
+      manifest.options.test_levels = ALL_TEST_LEVELS;
+      console.log();
+      console.log(chalk.cyan(msg.testLevelsMigrated || 'ℹ Test levels updated: 2 → 4 (added system-testing, e2e-testing)'));
+    }
+  }
+
   // Update manifest
   manifest.version = '3.3.0';
   manifest.upstream.version = latestVersion;
@@ -560,6 +635,74 @@ export async function updateCommand(options) {
   refreshIntegrationBlockHashes(manifest, projectPath);
   writeManifest(manifest, projectPath);
 
+  // Post-update integrity check: detect and restore missing files
+  const allTrackedFiles = [];
+  for (const std of manifest.standards) {
+    const fileName = basename(std);
+    const relativePath = std.includes('options/')
+      ? join('.standards', 'options', fileName)
+      : join('.standards', fileName);
+    allTrackedFiles.push(relativePath);
+  }
+  for (const ext of manifest.extensions) {
+    if (typeof ext !== 'string') continue;
+    const fileName = basename(ext);
+    allTrackedFiles.push(join('.standards', fileName));
+  }
+  for (const int of (manifest.integrations || [])) {
+    allTrackedFiles.push(int);
+  }
+
+  const missingFiles = allTrackedFiles.filter(f => !existsSync(join(projectPath, f)));
+
+  if (missingFiles.length > 0) {
+    console.log();
+    console.log(chalk.yellow((msg.missingAfterUpdate || '⚠ {count} file(s) still missing after update').replace('{count}', missingFiles.length)));
+
+    let shouldRestore = false;
+    if (options.yes) {
+      shouldRestore = true;
+    } else {
+      const { restoreMissing } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'restoreMissing',
+          message: (msg.restoreMissingPrompt || 'Restore {count} missing file(s)?').replace('{count}', missingFiles.length),
+          default: true
+        }
+      ]);
+      shouldRestore = restoreMissing;
+    }
+
+    if (shouldRestore) {
+      const restoreSpinner = ora((msg.restoringMissing || 'Restoring missing files...')).start();
+      const checkMsg = t().commands.check;
+      let restoredCount = 0;
+
+      for (const relativePath of missingFiles) {
+        const success = await restoreSingleFile(projectPath, manifest, relativePath, checkMsg);
+        if (success) restoredCount++;
+      }
+
+      restoreSpinner.succeed(
+        (msg.restoredCount || 'Restored {restored}/{total} file(s)')
+          .replace('{restored}', restoredCount)
+          .replace('{total}', missingFiles.length)
+      );
+
+      // Re-write manifest with updated hashes from restored files
+      writeManifest(manifest, projectPath);
+
+      // Re-generate integration files if files were restored and AI tools are configured
+      // This ensures CLAUDE.md / AGENTS.md standards index reflects restored files
+      if (restoredCount > 0 && manifest.aiTools?.length > 0) {
+        regenerateIntegrations(projectPath, manifest);
+        refreshIntegrationBlockHashes(manifest, projectPath);
+        writeManifest(manifest, projectPath);
+      }
+    }
+  }
+
   // Summary
   console.log();
   console.log(chalk.green(msg.updateSuccess));
@@ -606,6 +749,17 @@ export async function updateCommand(options) {
             ...installSkills
           ];
 
+          // Derive location from installations if not set
+          if (!manifest.skills.location) {
+            const levels = manifest.skills.installations.map(s => s.level).filter(Boolean);
+            const uniqueLevels = [...new Set(levels)];
+            if (uniqueLevels.length === 1) {
+              manifest.skills.location = uniqueLevels[0];
+            } else if (uniqueLevels.length > 1) {
+              manifest.skills.location = 'multiple';
+            }
+          }
+
           // Update skill hashes for integrity tracking
           if (skillResult.allFileHashes) {
             if (!manifest.skillHashes) manifest.skillHashes = {};
@@ -631,6 +785,17 @@ export async function updateCommand(options) {
           if (!manifest.skills) manifest.skills = {};
           manifest.skills.version = repoInfo.skills.version;
 
+          // Derive location from installations if not set
+          if (!manifest.skills.location && manifest.skills.installations?.length > 0) {
+            const levels = manifest.skills.installations.map(s => s.level).filter(Boolean);
+            const uniqueLevels = [...new Set(levels)];
+            if (uniqueLevels.length === 1) {
+              manifest.skills.location = uniqueLevels[0];
+            } else if (uniqueLevels.length > 1) {
+              manifest.skills.location = 'multiple';
+            }
+          }
+
           // Update skill hashes for integrity tracking
           if (updateResult.allFileHashes) {
             if (!manifest.skillHashes) manifest.skillHashes = {};
@@ -664,7 +829,7 @@ export async function updateCommand(options) {
           // Update command hashes for integrity tracking
           if (cmdResult.allFileHashes) {
             if (!manifest.commandHashes) manifest.commandHashes = {};
-            Object.assign(manifest.commandHashes, cmdResult.allFileHashes);
+            replaceCommandHashesForUpdatedAgents(manifest.commandHashes, cmdResult.allFileHashes);
           }
 
           if (cmdResult.totalErrors === 0) {
@@ -689,7 +854,7 @@ export async function updateCommand(options) {
           // Update command hashes for integrity tracking
           if (updateCmdResult.allFileHashes) {
             if (!manifest.commandHashes) manifest.commandHashes = {};
-            Object.assign(manifest.commandHashes, updateCmdResult.allFileHashes);
+            replaceCommandHashesForUpdatedAgents(manifest.commandHashes, updateCmdResult.allFileHashes);
           }
 
           if (updateCmdResult.totalErrors === 0) {
@@ -735,6 +900,15 @@ export async function updateCommand(options) {
           installCommands.length > 0 || updateCommands.length > 0 ||
           declinedSkills.length > 0 || declinedCommands.length > 0;
         if (hasChanges) {
+          // Re-run integration update if new skills were installed
+          // This ensures CLAUDE.md / AGENTS.md standards index is up-to-date
+          if (installSkills.length > 0 || updateSkills.length > 0) {
+            const regenResult = regenerateIntegrations(projectPath, manifest);
+            if (regenResult.updated.length > 0) {
+              console.log(chalk.green(`  ✓ ${msg.syncedIntegrations.replace('{count}', regenResult.updated.length)}`));
+            }
+          }
+
           refreshIntegrationBlockHashes(manifest, projectPath);
           writeManifest(manifest, projectPath);
         }
@@ -795,8 +969,34 @@ export async function updateCommand(options) {
       console.log(chalk.gray(`  ${msg.skillsLatest}: ${skillsVersion}`));
       console.log();
 
-      // Check installation location to provide appropriate update instructions
-      const location = manifest.skills.location || 'unknown';
+      // Determine installation location using multiple sources
+      let location = manifest.skills.location;
+
+      // Derive from installations array if location not set
+      if (!location && manifest.skills.installations?.length > 0) {
+        const hasMarketplace = manifest.skills.installations.some(
+          inst => inst.level === 'marketplace' || inst.agent === 'marketplace'
+        );
+        if (hasMarketplace) {
+          location = 'marketplace';
+        } else {
+          const levels = manifest.skills.installations.map(inst => inst.level).filter(Boolean);
+          const uniqueLevels = [...new Set(levels)];
+          location = uniqueLevels.length === 1 ? uniqueLevels[0] : (uniqueLevels.length > 1 ? 'project' : null);
+        }
+      }
+
+      // Fall back to file-system detection if still unknown
+      if (!location) {
+        for (const tool of (manifest.aiTools || [])) {
+          const projInfo = getInstalledSkillsInfoForAgent(tool, 'project', projectPath);
+          const usrInfo = getInstalledSkillsInfoForAgent(tool, 'user');
+          if (projInfo?.installed) { location = 'project'; break; }
+          if (usrInfo?.installed) { location = 'user'; break; }
+        }
+      }
+
+      location = location || 'unknown';
 
       if (location === 'marketplace') {
         console.log(chalk.gray(`  ${msg.updateViaMarketplace}`));
@@ -891,13 +1091,15 @@ export function regenerateIntegrations(projectPath, manifest) {
         if (!manifest.fileHashes) {
           manifest.fileHashes = {};
         }
-        manifest.fileHashes[result.path] = { ...hashInfo, installedAt: now };
+        const normalizedPath = result.path.replace(/\\/g, '/');
+        manifest.fileHashes[normalizedPath] = { ...hashInfo, installedAt: now };
       }
 
       // Track integration block hash for UDS content integrity
       if (result.blockHashInfo) {
         if (!manifest.integrationBlockHashes) manifest.integrationBlockHashes = {};
-        manifest.integrationBlockHashes[result.path] = {
+        const normalizedBlockPath = result.path.replace(/\\/g, '/');
+        manifest.integrationBlockHashes[normalizedBlockPath] = {
           ...result.blockHashInfo,
           installedAt: now
         };
@@ -907,6 +1109,27 @@ export function regenerateIntegrations(projectPath, manifest) {
     }
   }
 
+  // Regenerate universal AGENTS.md if enabled and not already covered
+  if (manifest.generateAgentsMd && !generatedFiles.has('AGENTS.md')) {
+    const summaryConfig = {
+      installedStandards: installedStandardsList,
+      language: manifest.options?.display_language || 'en',
+      commitLanguage: manifest.options?.commit_language || 'english',
+      standardOptions: manifest.options || {}
+    };
+    const agentsMdResult = writeAgentsMdSummary(summaryConfig, projectPath);
+    if (agentsMdResult.success) {
+      results.updated.push(agentsMdResult.path);
+      if (agentsMdResult.blockHashInfo) {
+        if (!manifest.integrationBlockHashes) manifest.integrationBlockHashes = {};
+        manifest.integrationBlockHashes[agentsMdResult.path] = {
+          ...agentsMdResult.blockHashInfo,
+          installedAt: now
+        };
+      }
+    }
+  }
+
   return {
     success: results.errors.length === 0,
     updated: results.updated,
@@ -1052,13 +1275,15 @@ async function syncIntegrationReferences(projectPath, manifest) {
         if (!manifest.fileHashes) {
           manifest.fileHashes = {};
         }
-        manifest.fileHashes[integrationPath] = { ...hashInfo, installedAt: now };
+        const normalizedIntPath = integrationPath.replace(/\\/g, '/');
+        manifest.fileHashes[normalizedIntPath] = { ...hashInfo, installedAt: now };
       }
 
       // Track integration block hash for UDS content integrity
       if (result.blockHashInfo) {
         if (!manifest.integrationBlockHashes) manifest.integrationBlockHashes = {};
-        manifest.integrationBlockHashes[integrationPath] = {
+        const normalizedIntBlockPath = integrationPath.replace(/\\/g, '/');
+        manifest.integrationBlockHashes[normalizedIntBlockPath] = {
           ...result.blockHashInfo,
           installedAt: now
         };
@@ -1301,7 +1526,7 @@ async function updateCommandsOnly(projectPath, manifest) {
   // Update command hashes for integrity tracking
   if (result.allFileHashes) {
     if (!manifest.commandHashes) manifest.commandHashes = {};
-    Object.assign(manifest.commandHashes, result.allFileHashes);
+    replaceCommandHashesForUpdatedAgents(manifest.commandHashes, result.allFileHashes);
   }
 
   writeManifest(manifest, projectPath);
@@ -1410,16 +1635,16 @@ function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = fa
         const installedInfo = userInfo || projectInfo;
         const installedVersion = installedInfo?.version;
 
-        // Skip marketplace (auto-updates) and unknown versions
-        if (!usingMarketplace && installedVersion && installedVersion !== latestSkillsVersion) {
+        // Skip marketplace (auto-updates); treat unknown versions as outdated
+        if (!usingMarketplace && (!installedVersion || installedVersion !== latestSkillsVersion)) {
           if (debug) {
-            console.log(chalk.yellow(`    ✓ Added to outdatedSkills (${installedVersion} → ${latestSkillsVersion})`));
+            console.log(chalk.yellow(`    ✓ Added to outdatedSkills (${installedVersion || 'unknown'} → ${latestSkillsVersion})`));
           }
           outdatedSkills.push({
             agent: tool,
             displayName: getAgentDisplayName(tool),
             paths: config.skills,
-            currentVersion: installedVersion,
+            currentVersion: installedVersion || 'unknown',
             latestVersion: latestSkillsVersion,
             level: userInfo?.installed ? 'user' : 'project',
             path: installedInfo?.path
@@ -1474,16 +1699,16 @@ function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = fa
           console.log(chalk.gray(`      latestSkillsVersion: ${latestSkillsVersion}`));
         }
 
-        // Check if version differs from latest
-        if (installedCmdVersion && installedCmdVersion !== latestSkillsVersion) {
+        // Check if version differs from latest; treat unknown versions as outdated
+        if (!installedCmdVersion || installedCmdVersion !== latestSkillsVersion) {
           if (debug) {
-            console.log(chalk.yellow(`    ✓ Added to outdatedCommands (${installedCmdVersion} → ${latestSkillsVersion})`));
+            console.log(chalk.yellow(`    ✓ Added to outdatedCommands (${installedCmdVersion || 'unknown'} → ${latestSkillsVersion})`));
           }
           outdatedCommands.push({
             agent: tool,
             displayName: getAgentDisplayName(tool),
             paths: config.commands,
-            currentVersion: installedCmdVersion,
+            currentVersion: installedCmdVersion || 'unknown',
             latestVersion: latestSkillsVersion,
             level: userCmdInfo?.installed ? 'user' : 'project',
             path: installedCmdInfo?.path

package/src/config/ai-agent-paths.js

@@ -464,6 +464,7 @@ export const AVAILABLE_COMMANDS = [
   { name: 'bdd', description: 'Guide BDD workflow (Gherkin, Given-When-Then)' },
   { name: 'atdd', description: 'Guide ATDD workflow (acceptance criteria)' },
   { name: 'coverage', description: 'Analyze test coverage (8 dimensions)' },
+  { name: 'ac-coverage', description: 'Generate AC traceability matrix and coverage report' },
 
   // ═══════════════════════════════════════════════════════════════════════════
   // Specification and Requirements (Action Skills)
@@ -505,6 +506,21 @@ export const AVAILABLE_COMMANDS = [
   { name: 'methodology', description: 'Development methodology selection' },
   { name: 'dev-workflow', description: 'Guide for mapping development phases to UDS commands' },
 
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Operations and Infrastructure (Action Skills)
+  // ═══════════════════════════════════════════════════════════════════════════
+  { name: 'security', description: 'Security review and vulnerability assessment' },
+  { name: 'scan', description: 'Automated security scanning and dependency audit' },
+  { name: 'api-design', description: 'API design following REST, GraphQL, gRPC best practices' },
+  { name: 'database', description: 'Database design, migration planning, and query optimization' },
+  { name: 'ci-cd', description: 'CI/CD pipeline design, configuration, and optimization' },
+  { name: 'incident', description: 'Incident response, root cause analysis, and post-mortem' },
+  { name: 'pr', description: 'Pull request creation, review automation, and merge strategy' },
+  { name: 'metrics', description: 'Development metrics, code quality indicators, and project health' },
+  { name: 'durable', description: 'Workflow fault recovery with checkpoints, retries, and rollback' },
+  { name: 'migrate', description: 'Code migration, framework upgrades, and tech modernization' },
+  { name: 'audit', description: 'Audit standards compliance and generate reports' },
+
   // ═══════════════════════════════════════════════════════════════════════════
   // CLI Management (Commands-only, UDS CLI specific)
   // ═══════════════════════════════════════════════════════════════════════════

package/src/config/workflow-definitions.js

@@ -0,0 +1,184 @@
+/**
+ * Workflow Phase Definitions
+ *
+ * Defines the phase graphs for each workflow type (SDD, TDD, BDD).
+ * Used by WorkflowGate to validate phase transitions.
+ *
+ * @version 1.0.0
+ */
+
+/**
+ * SDD workflow phase graph
+ * Each phase lists its allowed predecessors (phases that must have been completed)
+ */
+export const SDD_PHASES = {
+  discuss: {
+    id: 'discuss',
+    label: 'Discuss',
+    predecessors: [],
+    description: 'Capture gray areas, lock scope'
+  },
+  create: {
+    id: 'create',
+    label: 'Create',
+    predecessors: [],  // discuss is recommended but not required
+    description: 'Write spec document'
+  },
+  review: {
+    id: 'review',
+    label: 'Review',
+    predecessors: ['create'],
+    description: 'Validate spec with stakeholders'
+  },
+  approve: {
+    id: 'approve',
+    label: 'Approve',
+    predecessors: ['review'],
+    description: 'Sign off on spec'
+  },
+  implement: {
+    id: 'implement',
+    label: 'Implement',
+    predecessors: ['approve'],
+    description: 'Code following approved spec'
+  },
+  verify: {
+    id: 'verify',
+    label: 'Verify',
+    predecessors: ['implement'],
+    description: 'Confirm implementation matches spec'
+  }
+};
+
+/**
+ * TDD workflow phase graph (cyclic)
+ */
+export const TDD_PHASES = {
+  red: {
+    id: 'red',
+    label: 'RED',
+    predecessors: [],  // Entry point, or after refactor
+    description: 'Write failing test'
+  },
+  green: {
+    id: 'green',
+    label: 'GREEN',
+    predecessors: ['red'],
+    description: 'Write minimal code to pass'
+  },
+  refactor: {
+    id: 'refactor',
+    label: 'REFACTOR',
+    predecessors: ['green'],
+    description: 'Improve code, keep tests passing'
+  }
+};
+
+/**
+ * BDD workflow phase graph
+ */
+export const BDD_PHASES = {
+  discovery: {
+    id: 'discovery',
+    label: 'Discovery',
+    predecessors: [],
+    description: 'Explore behavior with stakeholders'
+  },
+  formulation: {
+    id: 'formulation',
+    label: 'Formulation',
+    predecessors: ['discovery'],
+    description: 'Write Gherkin scenarios'
+  },
+  automation: {
+    id: 'automation',
+    label: 'Automation',
+    predecessors: ['formulation'],
+    description: 'Implement step definitions'
+  },
+  living_docs: {
+    id: 'living_docs',
+    label: 'Living Docs',
+    predecessors: ['automation'],
+    description: 'Maintain as documentation'
+  }
+};
+
+/**
+ * Phase prerequisite checks — machine-executable validation functions
+ * Each check returns { passed, message, guidance }
+ */
+export const PHASE_CHECKS = {
+  sdd: {
+    implement: [
+      {
+        id: 'spec_exists',
+        description: 'At least one spec file exists',
+        check: 'ls docs/specs/SPEC-*.md 2>/dev/null | head -1',
+        expectedCondition: 'non_empty',
+        guidance: 'No spec found. Run `/sdd create` to create one first.'
+      },
+      {
+        id: 'spec_approved',
+        description: 'Spec status is Approved',
+        check: 'grep -l "^status: Approved" docs/specs/SPEC-*.md 2>/dev/null | head -1',
+        expectedCondition: 'non_empty',
+        guidance: 'No approved spec found. Run `/sdd approve SPEC-XXX.md` first.'
+      }
+    ],
+    verify: [
+      {
+        id: 'implementation_exists',
+        description: 'Implementation commits exist for the spec',
+        check: 'grep -l "^status: Implemented\\|^status: Approved" docs/specs/SPEC-*.md 2>/dev/null | head -1',
+        expectedCondition: 'non_empty',
+        guidance: 'No implementation found. Run `/sdd implement SPEC-XXX.md` first.'
+      }
+    ]
+  },
+  tdd: {
+    green: [
+      {
+        id: 'failing_test_exists',
+        description: 'At least one failing test exists',
+        guidance: 'No failing test found. Write a test first (RED phase) before writing implementation code.'
+      }
+    ],
+    refactor: [
+      {
+        id: 'all_tests_passing',
+        description: 'All tests must be passing',
+        guidance: 'Some tests are still failing. Fix them first (GREEN phase) before refactoring.'
+      }
+    ]
+  },
+  bdd: {
+    formulation: [
+      {
+        id: 'examples_collected',
+        description: 'Concrete examples from discovery phase exist',
+        guidance: 'No examples collected yet. Complete the DISCOVERY phase first to gather concrete examples.'
+      }
+    ],
+    automation: [
+      {
+        id: 'feature_file_exists',
+        description: 'At least one .feature file exists',
+        check: 'ls tests/features/*.feature 2>/dev/null | head -1',
+        expectedCondition: 'non_empty',
+        guidance: 'No .feature file found. Write Gherkin scenarios first (FORMULATION phase).'
+      }
+    ]
+  }
+};
+
+/**
+ * All workflow definitions indexed by name
+ */
+export const WORKFLOW_DEFINITIONS = {
+  sdd: { phases: SDD_PHASES, checks: PHASE_CHECKS.sdd },
+  tdd: { phases: TDD_PHASES, checks: PHASE_CHECKS.tdd },
+  bdd: { phases: BDD_PHASES, checks: PHASE_CHECKS.bdd }
+};
+
+export default WORKFLOW_DEFINITIONS;

package/src/core/constants.js

@@ -330,6 +330,12 @@ export const DEFAULTS = {
   TEST_LEVELS: [TEST_LEVELS.UNIT_TESTING, TEST_LEVELS.INTEGRATION_TESTING]
 };
 
+/**
+ * AGENTS.md universal output flag
+ * When true, AGENTS.md is generated as a universal summary regardless of tool selection
+ */
+export const AGENTS_MD_UNIVERSAL = 'agents-md-universal';
+
 /**
  * Feature flags (for experimental features)
  */