gemstack-ai 1.3.0 → 2.0.0

package/src/lib/filesystem-safe.js

@@ -1,22 +1,92 @@
 const path = require('path');
 const fs = require('fs');
+const crypto = require('crypto');
 
-module.exports = {
-    resolveSafe: (targetDir, relativePath) => {
-        const target = path.resolve(targetDir);
-        const candidate = path.resolve(targetDir, relativePath);
-        const rel = path.relative(target, candidate);
-        
-        const isInside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-        
-        if (!isInside) {
-            throw new Error(`Path Traversal blocked: ${relativePath}`);
+function normalizePlatformPath(p) {
+    const resolved = path.resolve(p);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function resolveSafe(targetDir, relativePath) {
+    const target = path.resolve(targetDir);
+    const candidate = path.resolve(targetDir, relativePath);
+    const rel = path.relative(target, candidate);
+    
+    const isInside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+    
+    if (!isInside) {
+        const err = new Error(`[PATH_TRAVERSAL_DETECTED] Path Traversal blocked: ${relativePath}`);
+        err.code = 'PATH_TRAVERSAL_DETECTED';
+        throw err;
+    }
+    return candidate;
+}
+
+function resolveSafeStrict(targetDir, relativePath) {
+    const candidate = resolveSafe(targetDir, relativePath);
+    const target = path.resolve(targetDir);
+
+    const realRoot = fs.existsSync(target) ? fs.realpathSync(target) : target;
+    const normRoot = normalizePlatformPath(realRoot);
+
+    // Check intermediate components and candidate for symlink escapes
+    const rel = path.relative(target, candidate);
+    const parts = rel.split(/[\\/]/).filter(Boolean);
+
+    let current = target;
+    for (const part of parts) {
+        current = path.join(current, part);
+        if (fs.existsSync(current)) {
+            const realCurrent = fs.realpathSync(current);
+            const normCurrent = normalizePlatformPath(realCurrent);
+            if (!normCurrent.startsWith(normRoot) || (normCurrent !== normRoot && normCurrent[normRoot.length] !== path.sep && normCurrent[normRoot.length] !== '/' && normCurrent[normRoot.length] !== '\\')) {
+                const err = new Error(`Symlink escape detected: path component "${part}" resolves to "${realCurrent}" outside project root "${realRoot}"`);
+                err.code = 'SYMLINK_ESCAPE_DETECTED';
+                throw err;
+            }
+        }
+    }
+
+    if (fs.existsSync(candidate)) {
+        const realCandidate = fs.realpathSync(candidate);
+        const normCandidate = normalizePlatformPath(realCandidate);
+        if (!normCandidate.startsWith(normRoot)) {
+            const err = new Error(`Symlink escape detected: destination resolves to "${realCandidate}" outside project root "${realRoot}"`);
+            err.code = 'SYMLINK_ESCAPE_DETECTED';
+            throw err;
         }
-        return candidate;
-    },
-    ensureDir: (dirPath) => {
-        if (!fs.existsSync(dirPath)) {
-            fs.mkdirSync(dirPath, { recursive: true });
+    }
+
+    return candidate;
+}
+
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
+function withConfinedAtomicWrite(rootDir, relativePath, writeFn) {
+    const finalPath = resolveSafeStrict(rootDir, relativePath);
+    const tmpDir = path.join(path.resolve(rootDir), '.gemstack', 'tmp');
+    ensureDir(tmpDir);
+
+    const tmpFile = path.join(tmpDir, `atomic-${Date.now()}-${crypto.randomBytes(4).toString('hex')}.tmp`);
+    try {
+        writeFn(tmpFile);
+        ensureDir(path.dirname(finalPath));
+        fs.renameSync(tmpFile, finalPath);
+        return finalPath;
+    } finally {
+        if (fs.existsSync(tmpFile)) {
+            try { fs.unlinkSync(tmpFile); } catch {}
         }
     }
+}
+
+module.exports = {
+    resolveSafe,
+    resolveSafeStrict,
+    ensureDir,
+    withConfinedAtomicWrite
 };

package/src/lib/memory-audit.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Memory Cross-Audit Engine (Gemstack 2.0 Sprint D)
+ * Reconciles git commit log with handoff.md to detect unrecorded work and memory drift.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const fssafe = require('./filesystem-safe');
+
+const MANDATORY_SECTIONS = [
+  '1. Objetivo',
+  '2. Estado actual',
+  '3. Archivos y cambios',
+  '4. Intentos fallidos',
+  '5. Próximos pasos'
+];
+
+/**
+ * Extracts recent git commits offline from the repository log.
+ * @param {string} targetDir 
+ * @param {number} limit 
+ * @returns {Array<{ hash: string, message: string }>}
+ */
+function getRecentGitCommits(targetDir, limit = 5) {
+  try {
+    const gitRes = spawnSync('git', ['log', `-n${limit}`, '--oneline'], {
+      cwd: targetDir,
+      encoding: 'utf8',
+      shell: false
+    });
+
+    if (gitRes.status !== 0 || !gitRes.stdout) {
+      return [];
+    }
+
+    return gitRes.stdout
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map(line => {
+        const parts = line.trim().split(' ');
+        const hash = parts[0];
+        const message = parts.slice(1).join(' ');
+        return { hash, message };
+      });
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Validates handoff integrity and cross-checks recent git commits against handoff records.
+ * @param {string} targetDir - Directory containing handoff.md
+ * @param {object} options - { commits?: Array<{ hash: string, message: string }>, limit?: number }
+ * @returns {{ valid: boolean, handoff_intact: boolean, unrecorded_commits: Array<object>, error?: string }}
+ */
+function crossAuditMemoryWithGit(targetDir, options = {}) {
+  const handoffPath = fssafe.resolveSafe(targetDir, 'handoff.md');
+  if (!fs.existsSync(handoffPath)) {
+    return {
+      valid: false,
+      handoff_intact: false,
+      unrecorded_commits: [],
+      error: 'handoff.md no encontrado en el directorio raíz'
+    };
+  }
+
+  const handoffContent = fs.readFileSync(handoffPath, 'utf8');
+
+  // 1. Verify mandatory sections
+  for (const sec of MANDATORY_SECTIONS) {
+    if (!handoffContent.includes(sec)) {
+      return {
+        valid: false,
+        handoff_intact: false,
+        missing_section: sec,
+        unrecorded_commits: [],
+        error: `handoff.md carece de la sección obligatoria: "${sec}".`
+      };
+    }
+  }
+
+  // 2. Obtain commits to check
+  const commits = options.commits || getRecentGitCommits(targetDir, options.limit || 5);
+  const unrecordedCommits = [];
+
+  for (const c of commits) {
+    // Check if commit hash or key terms of message are mentioned in handoff
+    const hashFound = c.hash && handoffContent.toLowerCase().includes(c.hash.toLowerCase());
+    
+    // Extract meaningful words (length >= 5) from commit message
+    const words = c.message
+      ? c.message
+          .replace(/[^\w\s-]/g, '')
+          .split(/\s+/)
+          .filter(w => w.length >= 5)
+      : [];
+
+    const wordsFound = words.length > 0 && words.some(w => handoffContent.toLowerCase().includes(w.toLowerCase()));
+
+    if (!hashFound && !wordsFound) {
+      unrecordedCommits.push(c);
+    }
+  }
+
+  return {
+    valid: unrecordedCommits.length === 0,
+    handoff_intact: true,
+    unrecorded_commits: unrecordedCommits,
+    recent_commits_checked: commits.length
+  };
+}
+
+module.exports = {
+  MANDATORY_SECTIONS,
+  getRecentGitCommits,
+  crossAuditMemoryWithGit
+};

package/src/lib/provider-boundary.js

@@ -34,13 +34,17 @@ function normalizeProviderId(rawId) {
  * @param {object} [tokenPayload={}]
  * @returns {string} SHA-256 bound token
  */
-function createBoundToken(providerId, capabilityId, actionId, tokenPayload = {}) {
+function createBoundToken(providerId, capabilityId, actionId, tokenPayload = {}, secret = null) {
   const payload = JSON.stringify({
     providerId,
     capabilityId,
     actionId,
     token: tokenPayload
   });
+  const effectiveSecret = secret || process.env.GEMSTACK_BOUNDARY_SECRET;
+  if (effectiveSecret) {
+    return crypto.createHmac('sha256', effectiveSecret).update(payload, 'utf8').digest('hex');
+  }
   return crypto.createHash('sha256').update(payload, 'utf8').digest('hex');
 }
 

package/src/lib/provider-registry.js

@@ -17,12 +17,14 @@ const REMOTE_URL_PATTERN = /^https?:\/\//i;
 function resolveEnvironmentTier(options = {}) {
   const env = options.env || process.env;
 
-  if (options.environment && VALID_ENV_TIERS.includes(options.environment)) {
-    return options.environment;
+  const rawEnv = (options.environment || '').toLowerCase().trim();
+  if (rawEnv && VALID_ENV_TIERS.includes(rawEnv)) {
+    return rawEnv;
   }
 
-  if (env.GEMSTACK_ENV && VALID_ENV_TIERS.includes(env.GEMSTACK_ENV)) {
-    return env.GEMSTACK_ENV;
+  const rawGemstackEnv = (env.GEMSTACK_ENV || '').toLowerCase().trim();
+  if (rawGemstackEnv && VALID_ENV_TIERS.includes(rawGemstackEnv)) {
+    return rawGemstackEnv;
   }
 
   // Detect CI first

package/src/lib/safety-gates.js

@@ -1,5 +1,71 @@
+const crypto = require('crypto');
 const { checkEnvironmentCommercialPolicy, resolveEnvironmentTier } = require('./provider-registry');
 
+const tokenSpendingLedger = new Map();
+
+function resetTokenSpendingLedger() {
+  tokenSpendingLedger.clear();
+}
+
+/**
+ * Issues a cryptographically signed spending token from a trusted boundary.
+ *
+ * @param {object} params
+ * @param {string} [params.secret]
+ * @param {string} [params.provider_id='*']
+ * @param {string} [params.action_id='*']
+ * @param {number} [params.max_budget_units=100]
+ * @param {number} [params.ttl_seconds=3600]
+ * @returns {object} Signed spending token
+ */
+function issueSpendingToken({ secret, provider_id = '*', action_id = '*', max_budget_units = 100, ttl_seconds = 3600 } = {}) {
+  const tokenId = (crypto.randomUUID && typeof crypto.randomUUID === 'function')
+    ? crypto.randomUUID()
+    : crypto.randomBytes(16).toString('hex');
+  const now = Date.now();
+  const issuedAt = new Date(now).toISOString();
+  const expiresAt = new Date(now + ttl_seconds * 1000).toISOString();
+  const effectiveSecret = secret || process.env.GEMSTACK_BOUNDARY_SECRET || 'gemstack-boundary-internal-signing-secret';
+
+  const payload = [tokenId, provider_id, action_id, String(max_budget_units), expiresAt].join(':');
+  const signature = crypto.createHmac('sha256', effectiveSecret).update(payload).digest('hex');
+
+  return {
+    token_id: tokenId,
+    provider_id,
+    action_id,
+    max_budget_units: Number(max_budget_units),
+    issued_at: issuedAt,
+    expires_at: expiresAt,
+    signature,
+    spent_units: 0
+  };
+}
+
+/**
+ * Verifies a spending token signature and expiration.
+ *
+ * @param {object} token
+ * @param {string} [secret]
+ * @returns {{ valid: boolean, reason?: string }}
+ */
+function verifySpendingToken(token, secret) {
+  if (!token || typeof token !== 'object') return { valid: false, reason: 'TOKEN_INVALID_FORMAT' };
+  if (!token.token_id || !token.signature || !token.expires_at) return { valid: false, reason: 'TOKEN_INCOMPLETE' };
+
+  const effectiveSecret = secret || process.env.GEMSTACK_BOUNDARY_SECRET || 'gemstack-boundary-internal-signing-secret';
+  const payload = [token.token_id, token.provider_id || '*', token.action_id || '*', String(token.max_budget_units), token.expires_at].join(':');
+  const expectedSig = crypto.createHmac('sha256', effectiveSecret).update(payload).digest('hex');
+
+  const bufA = Buffer.from(token.signature);
+  const bufB = Buffer.from(expectedSig);
+  if (bufA.length !== bufB.length || !crypto.timingSafeEqual(bufA, bufB)) {
+    return { valid: false, reason: 'TOKEN_SIGNATURE_INVALID' };
+  }
+
+  return { valid: true };
+}
+
 /**
  * Creates a normalized, structured gate decision object.
  *
@@ -155,7 +221,17 @@ function evaluateBillableAction(request, ledger, options = {}) {
   const providerId = (request.provider_id || '').toLowerCase().trim();
   const capabilityId = request.capability_id;
   const envTier = resolveEnvironmentTier({ environment: request.environment, ...options });
-  const requestedUnits = typeof request.requested_units === 'number' ? request.requested_units : 1;
+  const requestedUnits = request.requested_units !== undefined ? request.requested_units : 1;
+
+  if (typeof requestedUnits !== 'number' || !Number.isFinite(requestedUnits) || requestedUnits <= 0) {
+    return createGateDecision({
+      authorized: false,
+      decision: 'DENY',
+      reasonCode: 'INVALID_REQUESTED_UNITS',
+      message: 'Requested units must be a strictly positive finite number.',
+      context: { action_id: actionId, provider_id: providerId, requested_units: requestedUnits }
+    });
+  }
 
   // 1. Action Declaration Check (Must be explicitly declared)
   if (!actionId || typeof actionId !== 'string' || !actionId.trim()) {
@@ -232,9 +308,7 @@ function evaluateBillableAction(request, ledger, options = {}) {
 
   // 5. BILLABLE / POTENTIALLY_BILLABLE Actions -> Require Explicit Spending Token
   const token = request.authorization_token;
-  const isTokenValid = token && (token.granted === true || token.granted_by || token.source === 'CLI_FLAG' || token.max_budget_units !== undefined);
-
-  if (!isTokenValid) {
+  if (!token || typeof token !== 'object') {
     return createGateDecision({
       authorized: false,
       decision: 'DENY',
@@ -244,20 +318,111 @@ function evaluateBillableAction(request, ledger, options = {}) {
     });
   }
 
+  const boundarySecret = options.boundarySecret || process.env.GEMSTACK_BOUNDARY_SECRET;
+
+  if (boundarySecret) {
+    const verified = verifySpendingToken(token, boundarySecret);
+    if (!verified.valid) {
+      return createGateDecision({
+        authorized: false,
+        decision: 'DENY',
+        reasonCode: 'BILLABLE_ACTION_UNAUTHORIZED',
+        message: 'Authorization token rejected by trusted boundary: ' + verified.reason,
+        context: { action_id: actionId, provider_id: providerId, reason: verified.reason }
+      });
+    }
+  } else if (token.signature && token.token_id) {
+    const verified = verifySpendingToken(token);
+    if (!verified.valid) {
+      return createGateDecision({
+        authorized: false,
+        decision: 'DENY',
+        reasonCode: 'BILLABLE_ACTION_UNAUTHORIZED',
+        message: 'Authorization token signature invalid.',
+        context: { action_id: actionId, provider_id: providerId }
+      });
+    }
+  } else {
+    // Legacy fallback only when no boundarySecret is active
+    const isTokenValid = token && (token.granted === true || token.granted_by || token.source === 'CLI_FLAG' || token.max_budget_units !== undefined);
+    if (!isTokenValid) {
+      return createGateDecision({
+        authorized: false,
+        decision: 'DENY',
+        reasonCode: 'BILLABLE_ACTION_UNAUTHORIZED',
+        message: 'Action "' + actionId + '" on provider "' + providerId + '" requires explicit spending authorization.',
+        context: { action_id: actionId, provider_id: providerId, capability_id: capabilityId, cost_state: costState, environment: envTier }
+      });
+    }
+  }
+
+  // Expiration check
+  if (token.expires_at) {
+    const expMs = Date.parse(token.expires_at);
+    if (!Number.isNaN(expMs) && Date.now() > expMs) {
+      return createGateDecision({
+        authorized: false,
+        decision: 'DENY',
+        reasonCode: 'TOKEN_EXPIRED',
+        message: 'Authorization token expired at ' + token.expires_at + '.',
+        context: { action_id: actionId, provider_id: providerId, expires_at: token.expires_at }
+      });
+    }
+  }
+
+  // Scope check (Provider & Action)
+  if (token.provider_id && token.provider_id !== '*' && token.provider_id.toLowerCase() !== providerId.toLowerCase()) {
+    return createGateDecision({
+      authorized: false,
+      decision: 'DENY',
+      reasonCode: 'TOKEN_SCOPE_MISMATCH',
+      message: 'Token scope provider "' + token.provider_id + '" does not match requested provider "' + providerId + '".',
+      context: { action_id: actionId, provider_id: providerId, token_provider: token.provider_id }
+    });
+  }
+
+  if (token.action_id && token.action_id !== '*' && token.action_id !== actionId) {
+    return createGateDecision({
+      authorized: false,
+      decision: 'DENY',
+      reasonCode: 'TOKEN_SCOPE_MISMATCH',
+      message: 'Token scope action "' + token.action_id + '" does not match requested action "' + actionId + '".',
+      context: { action_id: actionId, provider_id: providerId, token_action: token.action_id }
+    });
+  }
+
   // 6. Budget & Unit Threshold Check
   const estimatedUnitCost = (capabilityEntry && typeof capabilityEntry.estimated_unit_cost === 'number') ? capabilityEntry.estimated_unit_cost : 1;
   const estimatedTotalCost = requestedUnits * estimatedUnitCost;
 
   if (token && typeof token.max_budget_units === 'number') {
-    if (estimatedTotalCost > token.max_budget_units) {
+    const tokenId = token.token_id;
+    const currentSpent = tokenId ? (tokenSpendingLedger.get(tokenId) || 0) : 0;
+    const projectedTotal = currentSpent + estimatedTotalCost;
+
+    if (projectedTotal > token.max_budget_units) {
       return createGateDecision({
         authorized: false,
         decision: 'DENY',
         reasonCode: 'BUDGET_THRESHOLD_EXCEEDED',
-        message: 'Action "' + actionId + '" estimated cost (' + estimatedTotalCost + ') exceeds authorized budget limit (' + token.max_budget_units + ').',
-        context: { action_id: actionId, provider_id: providerId, capability_id: capabilityId, cost_state: costState, environment: envTier, estimated_total_cost: estimatedTotalCost, max_budget_units: token.max_budget_units }
+        message: 'Action "' + actionId + '" estimated cost (' + projectedTotal + ') exceeds authorized budget limit (' + token.max_budget_units + ').',
+        context: {
+          action_id: actionId,
+          provider_id: providerId,
+          capability_id: capabilityId,
+          cost_state: costState,
+          environment: envTier,
+          estimated_total_cost: estimatedTotalCost,
+          current_spent: currentSpent,
+          projected_total: projectedTotal,
+          max_budget_units: token.max_budget_units
+        }
       });
     }
+
+    if (tokenId) {
+      tokenSpendingLedger.set(tokenId, projectedTotal);
+    }
   }
 
   // 7. Full Authorization Pass
@@ -273,5 +438,8 @@ function evaluateBillableAction(request, ledger, options = {}) {
 module.exports = {
   createGateDecision,
   evaluateProviderCapability,
-  evaluateBillableAction
+  evaluateBillableAction,
+  issueSpendingToken,
+  verifySpendingToken,
+  resetTokenSpendingLedger
 };

package/src/lib/sdd-rigor.js

@@ -0,0 +1,181 @@
+'use strict';
+
+/**
+ * SDD Rigor Engine (Gemstack 2.0 Sprint C)
+ * Defines and enforces 4 levels of SDD rigor: quick, fix, feature, high-risk.
+ */
+
+const RIGOR_LEVELS = Object.freeze(['quick', 'fix', 'feature', 'high-risk']);
+
+/**
+ * Detects the declared rigor level from spec content or metadata.
+ * @param {string} specContent - Content of spec.md or quick.md
+ * @returns {string} Detected rigor level ('quick'|'fix'|'feature'|'high-risk')
+ */
+function detectRigorLevel(specContent) {
+  if (!specContent || typeof specContent !== 'string') {
+    return 'feature';
+  }
+
+  // Check YAML frontmatter: rigor: <level>
+  const frontmatterMatch = specContent.match(/^---\s*[\r\n]+([\s\S]*?)[\r\n]+---/);
+  if (frontmatterMatch) {
+    const rMatch = frontmatterMatch[1].match(/^\s*rigor:\s*([a-zA-Z0-9_-]+)/m);
+    if (rMatch) {
+      const level = rMatch[1].trim().toLowerCase();
+      if (!RIGOR_LEVELS.includes(level)) {
+        const err = new Error(`Nivel de rigor inválido "${level}". Niveles válidos: ${RIGOR_LEVELS.join(', ')}`);
+        err.code = 'INVALID_RIGOR_LEVEL';
+        throw err;
+      }
+      return level;
+    }
+  }
+
+  // Check Markdown annotations: **Rigor Level**: `level` or Rigor: level
+  const inlineMatch = specContent.match(/\*\*Rigor(?:\s+Level)?\*\*:\s*`?([a-zA-Z0-9_-]+)`?/i);
+  if (inlineMatch) {
+    const level = inlineMatch[1].trim().toLowerCase();
+    if (!RIGOR_LEVELS.includes(level)) {
+      const err = new Error(`Nivel de rigor inválido "${level}". Niveles válidos: ${RIGOR_LEVELS.join(', ')}`);
+      err.code = 'INVALID_RIGOR_LEVEL';
+      throw err;
+    }
+    return level;
+  }
+
+  return 'feature';
+}
+
+/**
+ * Validates requirements for a given rigor level.
+ * @param {string} rigorLevel - 'quick'|'fix'|'feature'|'high-risk'
+ * @param {object} context - Context containing specContent, planContent, tasksContent, testMatrix, sidecar, etc.
+ * @returns {{ valid: boolean, code?: string, error?: string, [key: string]: any }}
+ */
+function validateRigorRequirements(rigorLevel, context = {}) {
+  const normLevel = (rigorLevel || 'feature').toLowerCase();
+  if (!RIGOR_LEVELS.includes(normLevel)) {
+    const err = new Error(`Nivel de rigor inválido "${normLevel}".`);
+    err.code = 'INVALID_RIGOR_LEVEL';
+    throw err;
+  }
+
+  const {
+    specContent = '',
+    planContent = null,
+    tasksContent = null,
+    testMatrix = [],
+    sidecar = null
+  } = context;
+
+  switch (normLevel) {
+    case 'quick': {
+      if (!specContent || typeof specContent !== 'string' || specContent.trim().length === 0) {
+        return {
+          valid: false,
+          code: 'QUICK_SPEC_MISSING',
+          error: 'Quick rigor requires at least one spec or quick artifact'
+        };
+      }
+      return {
+        valid: true,
+        rigor: 'quick',
+        single_artifact_allowed: true
+      };
+    }
+
+    case 'fix': {
+      // Must have at least one regression test in the test matrix
+      const matrix = Array.isArray(testMatrix) ? testMatrix : [];
+      const regressionTest = matrix.find(t => {
+        const cat = (t.category || '').toUpperCase();
+        const id = (t.id || '').toUpperCase();
+        const desc = (t.description || '').toLowerCase();
+        return cat === 'REGRESSION' || id.includes('REG') || desc.includes('regression') || desc.includes('reproduce');
+      });
+
+      if (!regressionTest) {
+        return {
+          valid: false,
+          code: 'FIX_MISSING_REGRESSION_TEST',
+          error: 'Fix rigor requires at least one linked regression test in the test matrix (category REGRESSION or ID matching *REG*)'
+        };
+      }
+
+      return {
+        valid: true,
+        rigor: 'fix',
+        regression_test_id: regressionTest.id
+      };
+    }
+
+    case 'feature': {
+      if (!specContent) {
+        return { valid: false, code: 'FEATURE_SPEC_MISSING', error: 'Feature rigor requires spec.md' };
+      }
+      if (!planContent) {
+        return { valid: false, code: 'FEATURE_PLAN_MISSING', error: 'Feature rigor requires plan.md' };
+      }
+      if (!tasksContent) {
+        return { valid: false, code: 'FEATURE_TASKS_MISSING', error: 'Feature rigor requires tasks.md' };
+      }
+      return {
+        valid: true,
+        rigor: 'feature'
+      };
+    }
+
+    case 'high-risk': {
+      // 1. Threat Model in specContent
+      const hasThreatModel = context.hasThreatModel ||
+        /##\s+(?:[0-9.]+\s+)?(?:Threat\s+Model|Modelo\s+de\s+Amenazas)/i.test(specContent);
+      if (!hasThreatModel) {
+        return {
+          valid: false,
+          code: 'HIGH_RISK_MISSING_THREAT_MODEL',
+          error: 'High-risk rigor requires an explicit Threat Model section in spec.md'
+        };
+      }
+
+      // 2. Rollback Plan in planContent
+      const hasRollbackPlan = context.hasRollbackPlan ||
+        (planContent && /##\s+(?:[0-9.]+\s+)?(?:Rollback\s+Plan|Plan\s+de\s+Rollback)/i.test(planContent));
+      if (!hasRollbackPlan) {
+        return {
+          valid: false,
+          code: 'HIGH_RISK_MISSING_ROLLBACK_PLAN',
+          error: 'High-risk rigor requires an explicit Rollback Plan section in plan.md'
+        };
+      }
+
+      // 3. Dual human approvals in sidecar
+      const approvals = sidecar && Array.isArray(sidecar.approvals) ? sidecar.approvals : [];
+      const validApprovals = approvals.filter(a => a && a.approver && a.signature);
+      const uniqueApprovers = new Set(validApprovals.map(a => a.approver));
+
+      if (uniqueApprovers.size < 2) {
+        return {
+          valid: false,
+          code: 'HIGH_RISK_INSUFFICIENT_APPROVALS',
+          error: `High-risk rigor requires at least 2 distinct human approval signatures. Found: ${uniqueApprovers.size}`
+        };
+      }
+
+      return {
+        valid: true,
+        rigor: 'high-risk',
+        approvals_count: uniqueApprovers.size
+      };
+    }
+
+    default:
+      return { valid: false, code: 'UNKNOWN_RIGOR', error: `Unknown rigor: ${normLevel}` };
+  }
+}
+
+module.exports = {
+  RIGOR_LEVELS,
+  detectRigorLevel,
+  validateRigorRequirements
+};