@bicorne/task-flow 0.1.0 → 0.2.1

package/dist/hooks/phase-gate-validator.js

@@ -1,407 +1,346 @@
-"use strict";
-/**
- * hooks/phase-gate-validator.ts
- * Validate phase transition gates
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizePath = normalizePath;
-exports.normalizeValidationName = normalizeValidationName;
-exports.getValidationAliases = getValidationAliases;
-exports.isPassedStatus = isPassedStatus;
-exports.parseReviewConclusion = parseReviewConclusion;
-exports.parseReviewValidationMap = parseReviewValidationMap;
-exports.parseReviewReport = parseReviewReport;
-exports.deriveTransitionFromFilePath = deriveTransitionFromFilePath;
-exports.getTaskFilePath = getTaskFilePath;
-exports.readTaskJson = readTaskJson;
-exports.getValidationItems = getValidationItems;
-exports.getPlanningSummary = getPlanningSummary;
-exports.getPlanningList = getPlanningList;
-exports.getSnapshotValidationMap = getSnapshotValidationMap;
-exports.hasValidationPassed = hasValidationPassed;
-exports.assessTransitionGate = assessTransitionGate;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const config_1 = require("../lib/config");
-const state_1 = require("../lib/state");
-const constants_1 = require("../lib/constants");
-function normalizePath(inputPath, projectRoot) {
-    if (!inputPath || typeof inputPath !== 'string') {
-        return '';
-    }
-    const absolutePath = path.isAbsolute(inputPath) ? inputPath : path.resolve(projectRoot, inputPath);
-    return path.relative(projectRoot, absolutePath).replace(/\\/g, '/');
+let e, t, r, s, n;
+function i(e) {
+    return "function" != typeof WeakMap ? null : (i = function(e) {
+        return new WeakMap();
+    })(e);
 }
-function normalizeValidationName(name) {
-    return String(name || '')
-        .trim()
-        .toLowerCase()
-        .replace(/_/g, '-')
-        .replace(/\s+/g, '-');
+function o(e, t) {
+    var r, s, n;
+    if (!t && e && e.__esModule) return e;
+    if (null === e || "object" != typeof e && "function" != typeof e) return {
+        default: e
+    };
+    if ((r = i(t)) && r.has(e)) return r.get(e);
+    for(var o in s = {
+        __proto__: null
+    }, n = Object.defineProperty && Object.getOwnPropertyDescriptor, e)if ("default" !== o && Object.prototype.hasOwnProperty.call(e, o)) {
+        var a = n ? Object.getOwnPropertyDescriptor(e, o) : null;
+        a && (a.get || a.set) ? Object.defineProperty(s, o, a) : s[o] = e[o];
+    }
+    return s.default = e, r && r.set(e, s), s;
 }
-function getValidationAliases(validationName) {
-    const normalized = normalizeValidationName(validationName);
-    return constants_1.VALIDATION_ALIASES[normalized] || [normalized];
+function a(e, t) {
+    if (!e || 'string' != typeof e) return '';
+    let r = P.isAbsolute(e) ? e : P.resolve(t, e);
+    return P.relative(t, r).replace(/\\/g, '/');
 }
-function isPassedStatus(status) {
-    if (!status) {
-        return false;
-    }
-    const normalized = status.trim().toLowerCase();
-    return constants_1.VALIDATED_STATUSES.includes(normalized);
+function l(e) {
+    return String(e || '').trim().toLowerCase().replace(/_/g, '-').replace(/\s+/g, '-');
 }
-function parseReviewConclusion(content) {
-    const patterns = [
-        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*PASS\b/m, result: constants_1.REVIEW_CONCLUSION.PASS },
-        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*NEEDS_WORK\b/m, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
-        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*FAIL\b/m, result: constants_1.REVIEW_CONCLUSION.FAIL },
-        { regex: /^##\s*结论\s*:\s*PASS\b/m, result: constants_1.REVIEW_CONCLUSION.PASS },
-        { regex: /^##\s*结论\s*:\s*NEEDS_WORK\b/m, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
-        { regex: /^##\s*结论\s*:\s*FAIL\b/m, result: constants_1.REVIEW_CONCLUSION.FAIL },
-        { regex: /^#\s*PASS\b/m, result: constants_1.REVIEW_CONCLUSION.PASS },
-        { regex: /^#\s*NEEDS_WORK\b/m, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
-        { regex: /^#\s*FAIL\b/m, result: constants_1.REVIEW_CONCLUSION.FAIL },
-        { regex: /\*\*结论\*\*\s*:\s*PASS\b/, result: constants_1.REVIEW_CONCLUSION.PASS },
-        { regex: /\*\*结论\*\*\s*:\s*NEEDS_WORK\b/, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
-        { regex: /\*\*结论\*\*\s*:\s*FAIL\b/, result: constants_1.REVIEW_CONCLUSION.FAIL },
-        { regex: /\*\*PASS\*\*/, result: constants_1.REVIEW_CONCLUSION.PASS },
-        { regex: /\*\*NEEDS_WORK\*\*/, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
-        { regex: /\*\*FAIL\*\*/, result: constants_1.REVIEW_CONCLUSION.FAIL },
-        // Additional pattern for "结论 : NEEDS_WORK" format (with space before colon)
-        { regex: /结论\s*:\s*NEEDS_WORK\b/, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
-        { regex: /结论\s*:\s*PASS\b/, result: constants_1.REVIEW_CONCLUSION.PASS },
-        { regex: /结论\s*:\s*FAIL\b/, result: constants_1.REVIEW_CONCLUSION.FAIL },
+function u(e) {
+    let t = l(e);
+    return b.VALIDATION_ALIASES[t] || [
+        t
     ];
-    for (const { regex, result } of patterns) {
-        if (regex.test(content)) {
-            return result;
+}
+function p(e) {
+    if (!e) return !1;
+    let t = e.trim().toLowerCase();
+    return b.VALIDATED_STATUSES.includes(t);
+}
+function c(e) {
+    for (let { regex: t, result: r } of [
+        {
+            regex: /^\s*(?:结论 |Conclusion)\s*:\s*PASS\b/m,
+            result: b.REVIEW_CONCLUSION.PASS
+        },
+        {
+            regex: /^\s*(?:结论 |Conclusion)\s*:\s*NEEDS_WORK\b/m,
+            result: b.REVIEW_CONCLUSION.NEEDS_WORK
+        },
+        {
+            regex: /^\s*(?:结论 |Conclusion)\s*:\s*FAIL\b/m,
+            result: b.REVIEW_CONCLUSION.FAIL
+        },
+        {
+            regex: /^##\s*结论\s*:\s*PASS\b/m,
+            result: b.REVIEW_CONCLUSION.PASS
+        },
+        {
+            regex: /^##\s*结论\s*:\s*NEEDS_WORK\b/m,
+            result: b.REVIEW_CONCLUSION.NEEDS_WORK
+        },
+        {
+            regex: /^##\s*结论\s*:\s*FAIL\b/m,
+            result: b.REVIEW_CONCLUSION.FAIL
+        },
+        {
+            regex: /^#\s*PASS\b/m,
+            result: b.REVIEW_CONCLUSION.PASS
+        },
+        {
+            regex: /^#\s*NEEDS_WORK\b/m,
+            result: b.REVIEW_CONCLUSION.NEEDS_WORK
+        },
+        {
+            regex: /^#\s*FAIL\b/m,
+            result: b.REVIEW_CONCLUSION.FAIL
+        },
+        {
+            regex: /\*\*结论\*\*\s*:\s*PASS\b/,
+            result: b.REVIEW_CONCLUSION.PASS
+        },
+        {
+            regex: /\*\*结论\*\*\s*:\s*NEEDS_WORK\b/,
+            result: b.REVIEW_CONCLUSION.NEEDS_WORK
+        },
+        {
+            regex: /\*\*结论\*\*\s*:\s*FAIL\b/,
+            result: b.REVIEW_CONCLUSION.FAIL
+        },
+        {
+            regex: /\*\*PASS\*\*/,
+            result: b.REVIEW_CONCLUSION.PASS
+        },
+        {
+            regex: /\*\*NEEDS_WORK\*\*/,
+            result: b.REVIEW_CONCLUSION.NEEDS_WORK
+        },
+        {
+            regex: /\*\*FAIL\*\*/,
+            result: b.REVIEW_CONCLUSION.FAIL
+        },
+        {
+            regex: /结论\s*:\s*NEEDS_WORK\b/,
+            result: b.REVIEW_CONCLUSION.NEEDS_WORK
+        },
+        {
+            regex: /结论\s*:\s*PASS\b/,
+            result: b.REVIEW_CONCLUSION.PASS
+        },
+        {
+            regex: /结论\s*:\s*FAIL\b/,
+            result: b.REVIEW_CONCLUSION.FAIL
         }
-    }
+    ])if (t.test(e)) return r;
     return null;
 }
-function parseReviewValidationMap(content) {
-    const validationMap = {};
-    const regex = /^\s*[-*]?\s*([a-z][a-z0-9_-]*)\s*:\s*([A-Za-z0-9_-]+)\s*$/gm;
-    let match = regex.exec(content);
-    while (match) {
-        const key = match[1];
-        const value = match[2];
-        if (key && value) {
-            validationMap[normalizeValidationName(key)] = value;
-        }
-        match = regex.exec(content);
+function d(e) {
+    let t = {}, r = /^\s*[-*]?\s*([a-z][a-z0-9_-]*)\s*:\s*([A-Za-z0-9_-]+)\s*$/gm, s = r.exec(e);
+    for(; s;){
+        let n = s[1], i = s[2];
+        n && i && (t[l(n)] = i), s = r.exec(e);
     }
-    return validationMap;
+    return t;
 }
-function parseReviewReport(content) {
-    const conclusion = parseReviewConclusion(content);
-    const validationMap = parseReviewValidationMap(content);
-    if (conclusion && !validationMap['review-conclusion']) {
-        validationMap['review-conclusion'] = conclusion;
-    }
-    return {
-        conclusion,
-        validationMap,
+function g(e) {
+    let t = c(e), r = d(e);
+    return t && !r['review-conclusion'] && (r['review-conclusion'] = t), {
+        conclusion: t,
+        validationMap: r
     };
 }
-function deriveTransitionFromFilePath(filePath, config) {
-    const relativePath = normalizePath(filePath, config.projectRoot);
-    // Security: Prevent path traversal by ensuring path doesn't escape expected directories
-    if (relativePath.includes('..') || (relativePath.startsWith('/') && !relativePath.startsWith(config.projectRoot))) {
-        return null;
-    }
-    // Check if path is in harness directory or matches expected patterns
-    const isInHarness = relativePath.includes('.harness/');
-    const matchesTaskPattern = new RegExp(`^${normalizePath(config.tasksDirAbs, config.projectRoot)}/.+\\.json$`).test(relativePath);
-    const matchesSnapshotPattern = new RegExp(`^${normalizePath(config.snapshotsDirAbs, config.projectRoot)}/.+\\.json$`).test(relativePath);
-    const matchesReportPattern = new RegExp(`^${normalizePath(config.reportsDirAbs, config.projectRoot)}/.+\\.md$`).test(relativePath);
-    if (!isInHarness && !matchesTaskPattern && !matchesSnapshotPattern && !matchesReportPattern) {
-        return null;
-    }
-    const tasksPattern = new RegExp(`^${normalizePath(config.tasksDirAbs, config.projectRoot)}/.+\\.json$`);
-    const snapshotPattern = new RegExp(`^${normalizePath(config.snapshotsDirAbs, config.projectRoot)}/.+\\.json$`);
-    const reportPattern = new RegExp(`^${normalizePath(config.reportsDirAbs, config.projectRoot)}/.+\\.md$`);
-    if (tasksPattern.test(relativePath)) {
-        return { phaseCompleted: 'planning', nextPhase: 'implementation', relativePath };
-    }
-    if (snapshotPattern.test(relativePath) && /-impl\.json$/.test(relativePath)) {
-        return { phaseCompleted: 'implementation', nextPhase: 'review', relativePath };
-    }
-    if (reportPattern.test(relativePath) && /-review\.md$/.test(relativePath)) {
-        return { phaseCompleted: 'review', nextPhase: 'merge', relativePath };
-    }
-    return null;
+function m(e, t) {
+    let r = a(e, t.projectRoot);
+    if (r.includes('..') || r.startsWith('/') && !r.startsWith(t.projectRoot)) return null;
+    let s = r.includes('.harness/'), n = RegExp(`^${a(t.tasksDirAbs, t.projectRoot)}/.+\\.json$`).test(r), i = RegExp(`^${a(t.snapshotsDirAbs, t.projectRoot)}/.+\\.json$`).test(r), o = RegExp(`^${a(t.reportsDirAbs, t.projectRoot)}/.+\\.md$`).test(r);
+    if (!s && !n && !i && !o) return null;
+    let l = RegExp(`^${a(t.tasksDirAbs, t.projectRoot)}/.+\\.json$`), u = RegExp(`^${a(t.snapshotsDirAbs, t.projectRoot)}/.+\\.json$`), p = RegExp(`^${a(t.reportsDirAbs, t.projectRoot)}/.+\\.md$`);
+    return l.test(r) ? {
+        phaseCompleted: 'planning',
+        nextPhase: 'implementation',
+        relativePath: r
+    } : u.test(r) && /-impl\.json$/.test(r) ? {
+        phaseCompleted: 'implementation',
+        nextPhase: 'review',
+        relativePath: r
+    } : p.test(r) && /-review\.md$/.test(r) ? {
+        phaseCompleted: 'review',
+        nextPhase: 'merge',
+        relativePath: r
+    } : null;
 }
-function getTaskFilePath(config, taskId) {
-    return path.resolve(config.tasksDirAbs, `${taskId}.json`);
+function S(e, t) {
+    return P.resolve(e.tasksDirAbs, `${t}.json`);
 }
-function readTaskJson(config, taskId) {
-    const taskPath = getTaskFilePath(config, taskId);
-    if (!fs.existsSync(taskPath)) {
-        return null;
-    }
+function f(e, t) {
+    let r = S(e, t);
+    if (!x.existsSync(r)) return null;
     try {
-        return JSON.parse(fs.readFileSync(taskPath, 'utf8'));
-    }
-    catch {
+        return JSON.parse(x.readFileSync(r, 'utf8'));
+    } catch  {
         return null;
     }
 }
-function getValidationItems(taskJson, phaseName) {
-    if (!taskJson) {
-        return [];
-    }
-    if (phaseName === 'implementation') {
-        return Array.isArray(taskJson.validation?.commands) ? taskJson.validation.commands : [];
-    }
-    if (phaseName === 'review') {
-        return Array.isArray(taskJson.validation?.manual_checks) ? taskJson.validation.manual_checks : [];
-    }
-    return [];
+function E(e, t) {
+    return e ? 'implementation' === t ? Array.isArray(e.validation?.commands) ? e.validation.commands : [] : 'review' === t && Array.isArray(e.validation?.manual_checks) ? e.validation.manual_checks : [] : [];
 }
-function getPlanningSummary(taskJson) {
-    return taskJson?.implementation?.notes || '';
+function O(e) {
+    return e?.implementation?.notes || '';
 }
-function getPlanningList(taskJson, key) {
-    if (!taskJson) {
-        return [];
-    }
-    if (key === 'implementationSteps') {
-        const steps = Array.isArray(taskJson.implementation?.steps) ? taskJson.implementation.steps : [];
-        return steps.map((item) => (typeof item === 'string' ? item : item.step || ''));
-    }
-    if (key === 'testStrategy') {
-        return Array.isArray(taskJson.validation?.commands) ? taskJson.validation.commands : [];
-    }
-    return [];
+function h(e, t) {
+    return e ? 'implementationSteps' === t ? (Array.isArray(e.implementation?.steps) ? e.implementation.steps : []).map((e)=>'string' == typeof e ? e : e.step || '') : 'testStrategy' === t && Array.isArray(e.validation?.commands) ? e.validation.commands : [] : [];
 }
-function getSnapshotValidationMap(snapshotPath) {
-    if (!snapshotPath || !fs.existsSync(snapshotPath)) {
-        return {};
-    }
+function A(e) {
+    if (!e || !x.existsSync(e)) return {};
     try {
-        const snapshot = JSON.parse(fs.readFileSync(snapshotPath, 'utf8'));
-        const results = Array.isArray(snapshot.validationResults) ? snapshot.validationResults : [];
-        const map = {};
-        for (const result of results) {
-            if (!result?.name) {
-                continue;
-            }
-            const name = normalizeValidationName(result.name);
-            map[name] = isPassedStatus(result.status);
-        }
-        return map;
-    }
-    catch {
+        let t = JSON.parse(x.readFileSync(e, 'utf8')), r = Array.isArray(t.validationResults) ? t.validationResults : [], s = {};
+        for (let e of r)e?.name && (s[l(e.name)] = p(e.status));
+        return s;
+    } catch  {
         return {};
     }
 }
-function hasValidationPassed(validationName, snapshotValidationMap) {
-    const candidates = getValidationAliases(validationName).map(normalizeValidationName);
-    return candidates.some((item) => snapshotValidationMap[item] === true || isPassedStatus(snapshotValidationMap[item]));
+function C(e, t) {
+    return u(e).map(l).some((e)=>!0 === t[e] || p(t[e]));
 }
-/**
- * Validate planning phase
- */
-function validatePlanningPhase(taskJson, validations, config) {
-    const missingValidations = [];
-    const details = [];
-    const taskOutput = taskJson.metadata?.outputs?.task;
-    const taskOutputExists = taskOutput && fs.existsSync(path.resolve(config.projectRoot, taskOutput));
-    if (!taskOutputExists) {
-        missingValidations.push('planning-task-exists');
-    }
-    if (validations.includes('planning-ready')) {
-        const summary = getPlanningSummary(taskJson);
-        const implementationSteps = getPlanningList(taskJson, 'implementationSteps');
-        const testStrategy = getPlanningList(taskJson, 'testStrategy');
-        if (!summary) {
-            missingValidations.push('planning.summary');
-        }
-        if (implementationSteps.length === 0) {
-            missingValidations.push('planning.implementationSteps');
-        }
-        if (testStrategy.length === 0) {
-            missingValidations.push('planning.testStrategy');
-        }
-    }
-    return { missingValidations, details };
-}
-/**
- * Validate implementation phase
- */
-function validateImplementationPhase(validations, relativePath, config) {
-    const missingValidations = [];
-    const details = [];
-    const snapshotPath = path.resolve(config.projectRoot, relativePath);
-    const snapshotValidationMap = getSnapshotValidationMap(snapshotPath);
-    for (const validation of validations) {
-        if (!hasValidationPassed(validation, snapshotValidationMap)) {
-            missingValidations.push(validation);
-        }
-    }
-    details.push(`snapshot:${relativePath}`);
-    return { missingValidations, details };
-}
-/**
- * Validate review phase
- */
-function validateReviewPhase(validations, relativePath, config, stateReviewConclusion) {
-    const missingValidations = [];
-    const details = [];
-    let reviewConclusion = stateReviewConclusion;
-    const reportPath = path.resolve(config.projectRoot, relativePath);
-    if (!fs.existsSync(reportPath)) {
-        missingValidations.push('review-report-exists');
-        return { missingValidations, details, reviewConclusion };
-    }
-    const reportContent = fs.readFileSync(reportPath, 'utf8');
-    const parsedReport = parseReviewReport(reportContent);
-    if (parsedReport.conclusion) {
-        reviewConclusion = parsedReport.conclusion;
-    }
-    for (const validation of validations) {
-        const normalizedValidation = normalizeValidationName(validation);
-        if (normalizedValidation === 'review-conclusion') {
-            if (reviewConclusion !== 'PASS') {
-                missingValidations.push('review-conclusion=PASS');
+function R(e) {
+    let { taskId: t, filePath: r, state: s, config: n } = e, i = m(r, n);
+    if (!i) return {
+        allowed: !1,
+        skipped: !0,
+        reason: 'not-transition-artifact'
+    };
+    let o = f(n, t);
+    if (!o) return {
+        allowed: !1,
+        skipped: !1,
+        phaseCompleted: i.phaseCompleted,
+        nextPhase: i.nextPhase,
+        reason: `task-not-found:${a(S(n, t), n.projectRoot)}`
+    };
+    let u = E(o, i.phaseCompleted), p = [], c = [], d = s?.reviewConclusion || null;
+    if ('planning' === i.phaseCompleted) {
+        let e = function(e, t, r) {
+            let s = [], n = e.metadata?.outputs?.task;
+            if (n && x.existsSync(P.resolve(r.projectRoot, n)) || s.push('planning-task-exists'), t.includes('planning-ready')) {
+                let t = O(e), r = h(e, 'implementationSteps'), n = h(e, 'testStrategy');
+                t || s.push('planning.summary'), 0 === r.length && s.push('planning.implementationSteps'), 0 === n.length && s.push('planning.testStrategy');
             }
-            continue;
-        }
-        if (!hasValidationPassed(normalizedValidation, parsedReport.validationMap)) {
-            missingValidations.push(validation);
-        }
-    }
-    details.push(`report:${relativePath}`);
-    return { missingValidations, details, reviewConclusion };
-}
-/**
- * Assess transition gate
- * @param options - Options
- * @returns Gate assessment result
- */
-function assessTransitionGate(options) {
-    const { taskId, filePath, state, config } = options;
-    const transition = deriveTransitionFromFilePath(filePath, config);
-    if (!transition) {
-        return { allowed: false, skipped: true, reason: 'not-transition-artifact' };
-    }
-    const taskJson = readTaskJson(config, taskId);
-    if (!taskJson) {
-        return {
-            allowed: false,
-            skipped: false,
-            phaseCompleted: transition.phaseCompleted,
-            nextPhase: transition.nextPhase,
-            reason: `task-not-found:${normalizePath(getTaskFilePath(config, taskId), config.projectRoot)}`,
-        };
-    }
-    const validations = getValidationItems(taskJson, transition.phaseCompleted);
-    let missingValidations = [];
-    let details = [];
-    let reviewConclusion = state?.reviewConclusion || null;
-    if (transition.phaseCompleted === 'planning') {
-        const planningResult = validatePlanningPhase(taskJson, validations, config);
-        missingValidations = planningResult.missingValidations;
-        details = planningResult.details;
-    }
-    if (transition.phaseCompleted === 'implementation') {
-        const implResult = validateImplementationPhase(validations, transition.relativePath, config);
-        missingValidations = implResult.missingValidations;
-        details = implResult.details;
-    }
-    if (transition.phaseCompleted === 'review') {
-        const reviewResult = validateReviewPhase(validations, transition.relativePath, config, reviewConclusion);
-        missingValidations = reviewResult.missingValidations;
-        details = reviewResult.details;
-        reviewConclusion = reviewResult.reviewConclusion;
-    }
-    if (missingValidations.length > 0) {
-        return {
-            allowed: false,
-            skipped: false,
-            phaseCompleted: transition.phaseCompleted,
-            nextPhase: transition.nextPhase,
-            missingValidations,
-            details,
-            reviewConclusion,
-            reason: 'phase-validation-failed',
-        };
-    }
-    return {
-        allowed: true,
-        skipped: false,
-        phaseCompleted: transition.phaseCompleted,
-        nextPhase: transition.nextPhase,
-        validations,
-        details,
-        reviewConclusion,
-        reason: 'phase-validation-passed',
+            return {
+                missingValidations: s,
+                details: []
+            };
+        }(o, u, n);
+        p = e.missingValidations, c = e.details;
+    }
+    if ('implementation' === i.phaseCompleted) {
+        let e = function(e, t, r) {
+            let s = [], n = [], i = A(P.resolve(r.projectRoot, t));
+            for (let t of e)C(t, i) || s.push(t);
+            return n.push(`snapshot:${t}`), {
+                missingValidations: s,
+                details: n
+            };
+        }(u, i.relativePath, n);
+        p = e.missingValidations, c = e.details;
+    }
+    if ('review' === i.phaseCompleted) {
+        let e = function(e, t, r, s) {
+            let n = [], i = [], o = s, a = P.resolve(r.projectRoot, t);
+            if (!x.existsSync(a)) return n.push('review-report-exists'), {
+                missingValidations: n,
+                details: i,
+                reviewConclusion: o
+            };
+            let u = g(x.readFileSync(a, 'utf8'));
+            for (let t of (u.conclusion && (o = u.conclusion), e)){
+                let e = l(t);
+                if ('review-conclusion' === e) {
+                    'PASS' !== o && n.push('review-conclusion=PASS');
+                    continue;
+                }
+                C(e, u.validationMap) || n.push(t);
+            }
+            return i.push(`report:${t}`), {
+                missingValidations: n,
+                details: i,
+                reviewConclusion: o
+            };
+        }(u, i.relativePath, n, d);
+        p = e.missingValidations, c = e.details, d = e.reviewConclusion;
+    }
+    return p.length > 0 ? {
+        allowed: !1,
+        skipped: !1,
+        phaseCompleted: i.phaseCompleted,
+        nextPhase: i.nextPhase,
+        missingValidations: p,
+        details: c,
+        reviewConclusion: d,
+        reason: 'phase-validation-failed'
+    } : {
+        allowed: !0,
+        skipped: !1,
+        phaseCompleted: i.phaseCompleted,
+        nextPhase: i.nextPhase,
+        validations: u,
+        details: c,
+        reviewConclusion: d,
+        reason: 'phase-validation-passed'
     };
 }
-/**
- * Main entry point for hook usage
- */
-function main() {
-    const input = JSON.parse(process.argv[2] || '{}');
-    const filePath = input.tool_input?.file_path || input.tool_input?.path || '';
-    const config = (0, config_1.loadConfig)();
-    const state = (0, state_1.loadState)(config);
-    if (!state?.currentTask) {
-        process.exit(0);
-    }
-    const result = assessTransitionGate({ taskId: state.currentTask, filePath, state, config });
-    if (result.skipped) {
-        process.exit(0);
-    }
-    if (!result.allowed) {
-        console.error(`[PHASE-GATE] blocked ${result.phaseCompleted} -> ${result.nextPhase}: ${result.reason}`);
-        if (Array.isArray(result.missingValidations) && result.missingValidations.length > 0) {
-            console.error(`[PHASE-GATE] missing: ${result.missingValidations.join(', ')}`);
-        }
-        process.exit(2);
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var _ = exports, I = {
+    get assessTransitionGate () {
+        return R;
+    },
+    get default () {
+        return L;
+    },
+    get deriveTransitionFromFilePath () {
+        return m;
+    },
+    get getPlanningList () {
+        return h;
+    },
+    get getPlanningSummary () {
+        return O;
+    },
+    get getSnapshotValidationMap () {
+        return A;
+    },
+    get getTaskFilePath () {
+        return S;
+    },
+    get getValidationAliases () {
+        return u;
+    },
+    get getValidationItems () {
+        return E;
+    },
+    get hasValidationPassed () {
+        return C;
+    },
+    get isPassedStatus () {
+        return p;
+    },
+    get normalizePath () {
+        return a;
+    },
+    get normalizeValidationName () {
+        return l;
+    },
+    get parseReviewConclusion () {
+        return c;
+    },
+    get parseReviewReport () {
+        return g;
+    },
+    get parseReviewValidationMap () {
+        return d;
+    },
+    get readTaskJson () {
+        return f;
     }
-    process.exit(0);
-}
-if (require.main === module) {
-    main();
-}
-exports.default = {
-    assessTransitionGate,
-    deriveTransitionFromFilePath,
-    parseReviewConclusion,
-    parseReviewReport,
+};
+for(var N in I)Object.defineProperty(_, N, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(I, N).get
+});
+let x = /*#__PURE__*/ o(require("fs")), P = /*#__PURE__*/ o(require("path")), v = require("../lib/config"), y = require("../lib/state"), b = require("../lib/constants");
+require.main === module && (e = JSON.parse(process.argv[2] || '{}'), t = e.tool_input?.file_path || e.tool_input?.path || '', r = (0, v.loadConfig)(), s = (0, y.loadState)(r), s?.currentTask || process.exit(0), (n = R({
+    taskId: s.currentTask,
+    filePath: t,
+    state: s,
+    config: r
+})).skipped && process.exit(0), n.allowed || (console.error(`[PHASE-GATE] blocked ${n.phaseCompleted} -> ${n.nextPhase}: ${n.reason}`), Array.isArray(n.missingValidations) && n.missingValidations.length > 0 && console.error(`[PHASE-GATE] missing: ${n.missingValidations.join(', ')}`), process.exit(2)), process.exit(0));
+let L = {
+    assessTransitionGate: R,
+    deriveTransitionFromFilePath: m,
+    parseReviewConclusion: c,
+    parseReviewReport: g
 };