@boyingliu01/xp-gate 0.18.1 → 0.18.3

package/lib/install-skill.js

@@ -30,10 +30,18 @@ function getCliVersion() {
 }
 
 const SKILLS_REGISTRY = {
-  'sprint-flow': { repo: 'boyingliu01/xp-gate', path: 'skills/sprint-flow' },
+  'admin-template-guidelines': { repo: 'boyingliu01/xp-gate', path: 'skills/admin-template-guidelines' },
+  'batch-grill-me': { repo: 'boyingliu01/xp-gate', path: 'skills/batch-grill-me' },
   'delphi-review': { repo: 'boyingliu01/xp-gate', path: 'skills/delphi-review' },
-  'test-spec': { repo: 'boyingliu01/xp-gate', path: 'skills/test-spec' },
-  'ralph-loop': { repo: 'boyingliu01/xp-gate', path: 'skills/ralph-loop' }
+  'domain-modeling': { repo: 'boyingliu01/xp-gate', path: 'skills/domain-modeling' },
+  'grill-with-docs': { repo: 'boyingliu01/xp-gate', path: 'skills/grill-with-docs' },
+  'grilling': { repo: 'boyingliu01/xp-gate', path: 'skills/grilling' },
+  'improve-codebase-architecture': { repo: 'boyingliu01/xp-gate', path: 'skills/improve-codebase-architecture' },
+  'ralph-loop': { repo: 'boyingliu01/xp-gate', path: 'skills/ralph-loop' },
+  'sprint-flow': { repo: 'boyingliu01/xp-gate', path: 'skills/sprint-flow' },
+  'test-driven-development': { repo: 'boyingliu01/xp-gate', path: 'skills/test-driven-development' },
+  'test-specification-alignment': { repo: 'boyingliu01/xp-gate', path: 'skills/test-specification-alignment' },
+  'to-issues': { repo: 'boyingliu01/xp-gate', path: 'skills/to-issues' }
 };
 
 async function installSkill(name, options = {}) {

package/lib/mattpocock-license-verdict.json

@@ -2,6 +2,6 @@
   "verdict": "PASS",
   "license_type": "MIT",
   "sha256": "0e7ac423bf2c6e223b7c5b156f8cf72da49d748e56a1641402c31f22ad07dbb5",
-  "checked_at": "2026-07-27T08:52:37.842Z",
+  "checked_at": "2026-07-29T01:35:32.539Z",
   "source": "network"
 }

package/lib/phase-transition.js

@@ -496,4 +496,109 @@ async function handlePhaseTransition(args = []) {
   }
 }
 
-module.exports = { handlePhaseTransition, renderDashboard, PHASE_NAMES, validateEvidence };
+/**
+ * Read-only evidence check for a given phase. Validates evidence without modifying sprint state.
+ * D3 (Unify Evidence Validation): replaces sprint-gate.sh inline JSON parsing.
+ *
+ * @param {number} phase - Phase number (1-6)
+ * @param {string} projectDir - Project root directory
+ * @returns {{ ok: boolean, errors: string[], warnings: string[] }}
+ */
+function checkEvidence(phase, projectDir) {
+  return validateEvidence(phase, projectDir);
+}
+
+/**
+ * Validate .code-walkthrough-result.json for code walkthrough mode.
+ * Ported from githooks/pre-push Gate MW inline jq logic.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {{ ok: boolean, errors: string[], warnings: string[] }}
+ */
+function checkWalkthrough(projectDir) {
+  const walkthroughFile = path.join(projectDir, '.code-walkthrough-result.json');
+  const errors = [];
+  const warnings = [];
+
+  if (!fs.existsSync(walkthroughFile)) {
+    errors.push('.code-walkthrough-result.json not found — run delphi-review --mode code-walkthrough before push');
+    return { ok: false, errors, warnings };
+  }
+
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(walkthroughFile, 'utf8'));
+  } catch {
+    errors.push('.code-walkthrough-result.json is malformed JSON');
+    return { ok: false, errors, warnings };
+  }
+
+  // Check verdict
+  if (data.verdict !== 'APPROVED') {
+    errors.push(`Code walkthrough verdict is "${data.verdict}" — must be APPROVED`);
+    return { ok: false, errors, warnings };
+  }
+
+  // Check commit is ancestor of HEAD
+  if (data.commit) {
+    try {
+      execSync(`git merge-base --is-ancestor ${data.commit} HEAD`, {
+        cwd: projectDir, stdio: 'pipe',
+      });
+    } catch {
+      errors.push(`Code walkthrough commit ${data.commit} is not an ancestor of HEAD`);
+      return { ok: false, errors, warnings };
+    }
+  }
+
+  // Check expiration
+  if (data.expires) {
+    const expiry = new Date(data.expires).getTime();
+    if (Date.now() > expiry) {
+      errors.push(`Code walkthrough expired at ${data.expires}`);
+      return { ok: false, errors, warnings };
+    }
+  }
+
+  return { ok: true, errors, warnings };
+}
+
+/**
+ * D8 Layer 3: Check bypass audit log for any --no-verify bypassed commits on the current branch.
+ * Blocks phase transition if bypassed commits exist.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {{ ok: boolean, bypassedCommits: string[] }}
+ */
+function checkBypassAudit(projectDir) {
+  const auditFile = path.join(projectDir, '.xp-gate', 'bypass-audit.jsonl');
+  const bypassedCommits = [];
+
+  if (!fs.existsSync(auditFile)) {
+    return { ok: true, bypassedCommits };
+  }
+
+  const lines = fs.readFileSync(auditFile, 'utf8').trim().split('\n').filter(Boolean);
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === 'precommit_bypass' && entry.commit) {
+        // Verify the commit is on the current branch
+        try {
+          execSync(`git merge-base --is-ancestor ${entry.commit} HEAD`, {
+            cwd: projectDir, stdio: 'pipe',
+          });
+          bypassedCommits.push(entry.commit);
+        } catch {
+          // Commit not on current branch — not relevant
+        }
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return { ok: bypassedCommits.length === 0, bypassedCommits };
+}
+
+module.exports = { handlePhaseTransition, renderDashboard, PHASE_NAMES, validateEvidence, checkEvidence, checkWalkthrough, checkBypassAudit };

package/lib/sprint-init.js

@@ -166,10 +166,32 @@ async function handleSprintInit(args = []) {
     return 0;
   }
 
+  // Read previous sprint retro data for auto-population (Phase 6 / D7)
+  const historyDir = path.join(projectDir, '.sprint-history');
+  let previousRetro = null;
+  if (fs.existsSync(historyDir)) {
+    const entries = fs.readdirSync(historyDir).filter(f => f.startsWith('sprint-')).sort().reverse();
+    for (const entry of entries) {
+      if (entry.endsWith('.json') && !entry.includes('retro')) continue;
+      const retroPath = path.join(historyDir, entry);
+      if (fs.existsSync(retroPath)) {
+        try {
+          const raw = fs.readFileSync(retroPath, 'utf8');
+          previousRetro = JSON.parse(raw);
+          break;
+        } catch {
+          // Skip unparseable files
+        }
+      }
+      break; // Only check the most recent sprint
+    }
+  }
+
   // Create new sprint state
   const sprintId = generateSprintId();
   const newState = {
     _schema_version: 1,
+    evidence_schema_version: 2,  // Phase 5: new sprints default to full BLOCK enforcement
     id: sprintId,
     task_description: taskDescription.trim(),
     phase: 1,
@@ -191,6 +213,25 @@ async function handleSprintInit(args = []) {
     metrics: {},
   };
 
+  // Phase 6 / D7: Auto-populate from previous sprint retro data
+  if (previousRetro) {
+    if (previousRetro.rework_rate != null) {
+      newState.metrics.previous_rework_rate = previousRetro.rework_rate;
+    }
+    if (previousRetro.evidence_skips != null) {
+      newState.metrics.previous_evidence_skips = previousRetro.evidence_skips;
+    }
+    if (previousRetro.duration_seconds != null) {
+      newState.metrics.previous_duration_seconds = previousRetro.duration_seconds;
+    }
+    if (Object.keys(newState.metrics).length > 0) {
+      console.log('📊 Auto-populated from previous sprint retro data:');
+      for (const [key, value] of Object.entries(newState.metrics)) {
+        console.log(`   ${key}: ${value}`);
+      }
+    }
+  }
+
   // Write state atomically
   manager.write(newState);