@williambeto/ai-workflow 2.4.9 → 2.6.4

package/chunk-6EMG6FAO.js

@@ -0,0 +1,734 @@
+import {
+  ArtifactFidelityGate,
+  DeliveryDecisionEngine,
+  MergeGate,
+  StackDetector
+} from "./chunk-2AOV2ATY.js";
+
+// src/core/validation/quality-guard.ts
+import { execSync } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+var PROTECTED_BRANCHES = /* @__PURE__ */ new Set(["main", "master"]);
+function normalizePath(file) {
+  return String(file || "").trim().replaceAll("\\", "/");
+}
+function parseStatusLine(line) {
+  const value = String(line || "");
+  const match = value.match(/^(?:[ MADRCU?!]{2}\s+|[MADRCU?!]\s+)(.+)$/);
+  if (!match) return "";
+  const candidate = match[1].trim();
+  const renamed = candidate.includes(" -> ") ? candidate.split(" -> ").at(-1) : candidate;
+  return normalizePath(renamed);
+}
+function isManagedChangePath(file = "") {
+  return /(^|\/)(node_modules|vendor|dist|coverage|\.cache)(\/|$)/.test(normalizePath(file));
+}
+async function exists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var QualityGuard = class {
+  cwd;
+  taskSlug;
+  evidenceWillBePersisted;
+  evidencePolicy;
+  riskLevel;
+  _changedFiles;
+  _hasHead;
+  constructor({
+    cwd,
+    taskSlug = null,
+    evidenceWillBePersisted = false,
+    evidencePolicy = "optional",
+    riskLevel = "medium"
+  }) {
+    this.cwd = cwd;
+    this.taskSlug = taskSlug;
+    this.evidencePolicy = evidencePolicy || "optional";
+    this.riskLevel = riskLevel || "medium";
+    this._changedFiles = null;
+    this._hasHead = null;
+    this.evidenceWillBePersisted = evidenceWillBePersisted;
+  }
+  runGit(command) {
+    return execSync(command, {
+      cwd: this.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  }
+  hasGitHead() {
+    if (this._hasHead !== null) return this._hasHead;
+    try {
+      this.runGit("git rev-parse --verify HEAD");
+      this._hasHead = true;
+    } catch {
+      this._hasHead = false;
+    }
+    return this._hasHead;
+  }
+  getCurrentBranch() {
+    try {
+      return this.runGit("git branch --show-current") || "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  getChangedFiles() {
+    if (this._changedFiles) return this._changedFiles;
+    const files = /* @__PURE__ */ new Set();
+    try {
+      if (this.hasGitHead()) {
+        this.runGit("git diff --name-only HEAD").split("\n").map(normalizePath).filter(Boolean).forEach((file) => files.add(file));
+      }
+      this.runGit("git status --short --untracked-files=all").split("\n").map(parseStatusLine).filter(Boolean).filter((file) => !isManagedChangePath(file)).forEach((file) => files.add(file));
+    } catch {
+    }
+    this._changedFiles = [...files].sort();
+    return this._changedFiles;
+  }
+  isDocsTask() {
+    const files = this.getChangedFiles();
+    return files.length > 0 && files.every((file) => file.endsWith(".md") || file.endsWith(".txt") || file.startsWith("docs/"));
+  }
+  isUiTask() {
+    return this.getChangedFiles().some(
+      (file) => /\.(tsx|jsx|vue|html|css|scss|less|blade\.php)$/.test(file) || /(^|\/)(components|pages|views)\//.test(file)
+    );
+  }
+  isImplementationTask() {
+    const files = this.getChangedFiles();
+    if (files.length === 0 || this.isDocsTask()) return false;
+    return files.some(
+      (file) => file === "package.json" || /^(src|app|pages|components|server|api)\//.test(file) || /\.(js|jsx|ts|tsx|vue|php|py|rb|go|java|css|scss|html)$/.test(file)
+    );
+  }
+  async hasExecutableBehaviorChanges() {
+    const files = this.getChangedFiles().filter((file) => !isManagedChangePath(file));
+    const executableExtensions = /\.(js|jsx|mjs|cjs|ts|tsx|vue|php|py|rb|go|java|cs|rs|swift|kt|kts|sh|bash)$/i;
+    if (files.some((file) => executableExtensions.test(file))) return true;
+    for (const file of files.filter((item) => /\.(html?|xhtml)$/i.test(item))) {
+      try {
+        const content = await fs.readFile(path.join(this.cwd, file), "utf8");
+        if (/<script\b|\son(?:click|change|input|submit|keydown|keyup|load|error)\s*=|javascript:/i.test(content)) return true;
+      } catch {
+      }
+    }
+    return false;
+  }
+  verifyBranchSafety() {
+    const branch = this.getCurrentBranch();
+    const implementation = this.isImplementationTask();
+    if (!this.hasGitHead()) {
+      return { status: "PASS_WITH_NOTES", branch, reason: "Git HEAD unavailable; branch safety could not be verified." };
+    }
+    if (implementation && PROTECTED_BRANCHES.has(branch)) {
+      return { status: "FAIL_QUALITY_GATE", branch, reason: `Implementation changes are present on protected branch '${branch}'.` };
+    }
+    if (this.riskLevel === "high") {
+      const mergeGate = new MergeGate({ cwd: this.cwd });
+      const mergeResult = mergeGate.check(branch);
+      if (mergeResult.status === "FAIL_QUALITY_GATE") {
+        return { status: "FAIL_QUALITY_GATE", branch, reason: mergeResult.reason };
+      }
+    }
+    return { status: "PASS", branch };
+  }
+  async verifyDocumentationNeed() {
+    if (!this.isImplementationTask()) return { status: "NOT_RUN", reason: "No implementation changes detected." };
+    const files = this.getChangedFiles();
+    const docsChanged = files.some((file) => file === "README.md" || file.startsWith("docs/") || file.endsWith(".md"));
+    const publicSurfaceChanged = files.some(
+      (file) => file === "package.json" || /(^|\/)(routes?|api|cli|commands?|config|public)\//.test(file) || /README|CHANGELOG/.test(file)
+    );
+    if (publicSurfaceChanged && !docsChanged) {
+      return { status: "PASS_WITH_NOTES", reason: "Public behavior may have changed without a documentation update." };
+    }
+    return { status: "PASS" };
+  }
+  async verifyUiEvidence() {
+    if (!this.isUiTask()) return { status: "NOT_RUN", reason: "Non-UI task." };
+    const candidates = ["docs", "screenshots", "evidence"];
+    const found = [];
+    for (const dir of candidates) {
+      const root = path.join(this.cwd, dir);
+      if (!await exists(root)) continue;
+      const entries = await fs.readdir(root, { recursive: true }).catch(() => []);
+      for (const entry of entries) {
+        if (/\.(png|jpe?g|webp)$/i.test(String(entry))) found.push(normalizePath(path.join(dir, String(entry))));
+      }
+    }
+    return found.length ? { status: "PASS", screenshots: found.slice(0, 20) } : { status: "PASS_WITH_NOTES", reason: "UI changed without persisted screenshots; rely on the stated browser/manual review only if it actually occurred." };
+  }
+  async verifyPersistedEvidence() {
+    if (this.evidencePolicy !== "required") return { status: "NOT_RUN", reason: "Persisted evidence is optional under optional evidence policy." };
+    if (this.evidenceWillBePersisted) return { status: "PASS", reason: "Collector will persist observed evidence." };
+    const candidates = [
+      path.join(this.cwd, "EVIDENCE.json"),
+      this.taskSlug ? path.join(this.cwd, "docs/workflows", this.taskSlug, "evidence.json") : null
+    ].filter(Boolean);
+    for (const file of candidates) {
+      if (await exists(file)) return { status: "PASS", file: path.relative(this.cwd, file) };
+    }
+    return { status: "FAIL_QUALITY_GATE", reason: "Persisted evidence is required under required evidence policy." };
+  }
+  verifyTruthfulnessBoundary() {
+    if (!this.isUiTask()) return { status: "NOT_RUN", reason: "Non-UI task." };
+    return {
+      status: "NOT_RUN",
+      reason: "Product truthfulness requires semantic review; keyword matching is intentionally not used as proof."
+    };
+  }
+  async verify() {
+    const branchSafety = this.verifyBranchSafety();
+    const documentation = await this.verifyDocumentationNeed();
+    const uiEvidence = await this.verifyUiEvidence();
+    const persistedEvidence = await this.verifyPersistedEvidence();
+    const productTruthfulness = this.verifyTruthfulnessBoundary();
+    const checks = [branchSafety, documentation, uiEvidence, persistedEvidence];
+    let overallStatus = "PASS";
+    if (checks.some((check) => ["FAIL", "FAIL_QUALITY_GATE", "BLOCKED"].includes(check.status))) {
+      overallStatus = "FAIL_QUALITY_GATE";
+    } else if (checks.some((check) => check.status === "PASS_WITH_NOTES")) {
+      overallStatus = "PASS_WITH_NOTES";
+    }
+    return {
+      overallStatus,
+      isUiTask: this.isUiTask(),
+      isDocsTask: this.isDocsTask(),
+      isImplementationTask: this.isImplementationTask(),
+      git: {
+        hasHead: this.hasGitHead(),
+        branch: this.getCurrentBranch(),
+        changedFiles: this.getChangedFiles()
+      },
+      checks: {
+        branchSafety,
+        documentation,
+        uiEvidence,
+        persistedEvidence,
+        productTruthfulness
+      }
+    };
+  }
+};
+
+// src/core/validation/visual-verifier.ts
+import http from "http";
+import fs2 from "fs/promises";
+import path2 from "path";
+var VisualVerifier = class {
+  cwd;
+  visualDist;
+  port;
+  server;
+  constructor({ cwd = process.cwd(), visualDist = null, port = 8080 } = {}) {
+    this.cwd = cwd;
+    this.visualDist = visualDist;
+    this.port = Number(port || 8080);
+    this.server = null;
+  }
+  async startServer() {
+    if (!this.visualDist) {
+      throw new Error("No --visual-dist directory specified. Cannot start visual server.");
+    }
+    const distPath = path2.resolve(this.cwd, this.visualDist);
+    this.server = http.createServer(async (req, res) => {
+      try {
+        const urlPath = req.url?.split("?")[0] || "/";
+        const filePath = path2.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+        const content = await fs2.readFile(filePath);
+        const ext = path2.extname(filePath).toLowerCase();
+        let contentType = "text/html";
+        if (ext === ".js" || ext === ".mjs") contentType = "application/javascript";
+        else if (ext === ".css") contentType = "text/css";
+        else if (ext === ".png") contentType = "image/png";
+        else if (ext === ".jpg" || ext === ".jpeg") contentType = "image/jpeg";
+        else if (ext === ".svg") contentType = "image/svg+xml";
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content);
+      } catch (err) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      }
+    });
+    await new Promise((resolve, reject) => {
+      this.server.listen(this.port, "127.0.0.1", () => {
+        resolve();
+      });
+      this.server.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  async closeServer() {
+    if (this.server) {
+      await new Promise((resolve) => this.server.close(() => resolve()));
+      this.server = null;
+    }
+  }
+  async captureScreenshots() {
+    if (!this.visualDist) return [];
+    let playwright;
+    try {
+      playwright = await import("playwright");
+    } catch {
+      throw new Error(
+        "Playwright is required to capture visual evidence. Please install it using 'npm install -D playwright' and initialize browsers using 'npx playwright install'."
+      );
+    }
+    await this.startServer();
+    let browser;
+    try {
+      browser = await playwright.chromium.launch();
+    } catch (err) {
+      await this.closeServer();
+      throw new Error(
+        `Failed to launch Playwright Chromium. Please ensure browsers are installed using 'npx playwright install chromium'. Details: ${err.message}`
+      );
+    }
+    const page = await browser.newPage();
+    const outputDir = path2.join(this.cwd, ".evidence/visual");
+    await fs2.mkdir(outputDir, { recursive: true });
+    const desktopPath = path2.join(outputDir, "desktop.png");
+    const mobilePath = path2.join(outputDir, "mobile.png");
+    try {
+      await page.goto(`http://127.0.0.1:${this.port}`);
+      await page.setViewportSize({ width: 1440, height: 900 });
+      await page.screenshot({ path: desktopPath, fullPage: true });
+      await page.setViewportSize({ width: 390, height: 844 });
+      await page.screenshot({ path: mobilePath, fullPage: true });
+    } finally {
+      await browser.close();
+      await this.closeServer();
+    }
+    return [desktopPath, mobilePath];
+  }
+  async runAccessibilityCheck() {
+    if (!this.visualDist) {
+      throw new Error("Accessibility check requires a target build directory specified via --visual-dist.");
+    }
+    let playwright;
+    try {
+      playwright = await import("playwright");
+    } catch {
+      throw new Error(
+        "Playwright is required to run accessibility checks. Please install it using 'npm install -D playwright' and initialize browsers using 'npx playwright install'."
+      );
+    }
+    await this.startServer();
+    let browser;
+    try {
+      browser = await playwright.chromium.launch();
+    } catch (err) {
+      await this.closeServer();
+      throw new Error(
+        `Failed to launch Playwright Chromium. Please ensure browsers are installed using 'npx playwright install chromium'. Details: ${err.message}`
+      );
+    }
+    const page = await browser.newPage();
+    const outputDir = path2.join(this.cwd, ".evidence/a11y");
+    await fs2.mkdir(outputDir, { recursive: true });
+    try {
+      await page.goto(`http://127.0.0.1:${this.port}`);
+      let axeScript = "";
+      try {
+        const axePath = path2.join(this.cwd, "node_modules/axe-core/axe.min.js");
+        axeScript = await fs2.readFile(axePath, "utf8");
+      } catch {
+        try {
+          const mainAxePath = path2.resolve(import.meta.dirname, "../../../node_modules/axe-core/axe.min.js");
+          axeScript = await fs2.readFile(mainAxePath, "utf8");
+        } catch {
+          throw new Error("axe-core package is not installed. Please install axe-core using 'npm install -D axe-core'.");
+        }
+      }
+      await page.evaluate(axeScript);
+      const axeResults = await page.evaluate(() => {
+        return window.axe.run();
+      });
+      const reportPath = path2.join(outputDir, "report.json");
+      await fs2.writeFile(reportPath, JSON.stringify(axeResults, null, 2));
+      const criticalViolations = axeResults.violations.filter((v) => v.impact === "critical");
+      const seriousViolations = axeResults.violations.filter((v) => v.impact === "serious");
+      return {
+        passed: criticalViolations.length === 0,
+        reportPath,
+        violations: axeResults.violations,
+        critical: criticalViolations,
+        serious: seriousViolations
+      };
+    } finally {
+      await browser.close();
+      await this.closeServer();
+    }
+  }
+};
+
+// src/core/validation/evidence-collector.ts
+import { spawnSync } from "child_process";
+import fs3 from "fs/promises";
+import path3 from "path";
+var VALIDATION_KINDS = /* @__PURE__ */ new Set(["test", "build", "typecheck", "lint", "security", "smoke", "validate", "other"]);
+function publicStatus(status) {
+  if (status === "PASS") return "COMPLETED";
+  if (status === "PASS_WITH_NOTES") return "COMPLETED_WITH_NOTES";
+  return "BLOCKED";
+}
+function inferTaskKind(task = {}) {
+  const explicit = String(task.kind || "").trim().toLowerCase();
+  if (VALIDATION_KINDS.has(explicit)) return explicit;
+  const value = `${task.name || ""} ${task.command || ""}`.toLowerCase();
+  if (/\b(test|tests|vitest|jest|mocha|ava|tap|pytest|phpunit|rspec|cypress|playwright)\b/.test(value)) return "test";
+  if (/\b(typecheck|tsc\b|mypy|pyright)\b/.test(value)) return "typecheck";
+  if (/\b(lint|eslint|stylelint|ruff|flake8|pylint)\b/.test(value)) return "lint";
+  if (/\b(build|bundle|compile)\b/.test(value)) return "build";
+  if (/\b(audit|security|sast|scan)\b/.test(value)) return "security";
+  if (/\b(smoke|curl|preview|serve)\b/.test(value)) return "smoke";
+  if (/\bvalidate\b/.test(value)) return "validate";
+  return "other";
+}
+var EvidenceCollector = class {
+  cwd;
+  maxLogLength;
+  timeout;
+  taskSlug;
+  /** @deprecated use evidencePolicy instead */
+  mode;
+  evidencePolicy;
+  profile;
+  branchRecovery;
+  userRequest;
+  explicitApprovals;
+  visualDist;
+  port;
+  constructor({
+    cwd,
+    maxLogLength = 2e3,
+    timeout = 6e4,
+    taskSlug = null,
+    mode = null,
+    evidencePolicy = null,
+    profile = "generic",
+    branchRecovery = "NOT_RECORDED",
+    userRequest = null,
+    explicitApprovals = [],
+    visualDist = null,
+    port = 8080
+  }) {
+    this.cwd = cwd;
+    this.maxLogLength = maxLogLength;
+    this.timeout = timeout;
+    this.taskSlug = taskSlug;
+    this.evidencePolicy = evidencePolicy || (mode === "full" ? "required" : "optional");
+    this.mode = this.evidencePolicy === "required" ? "full" : "standard";
+    this.profile = profile;
+    this.branchRecovery = branchRecovery;
+    this.userRequest = userRequest;
+    this.explicitApprovals = explicitApprovals;
+    this.visualDist = visualDist;
+    this.port = Number(port || 8080);
+  }
+  async findUserRequest() {
+    if (this.userRequest) return this.userRequest;
+    if (this.taskSlug) {
+      const ledgerPath = path3.join(this.cwd, `.ai-workflow/history/${this.taskSlug}-ledger.json`);
+      try {
+        const content = await fs3.readFile(ledgerPath, "utf8");
+        const events = JSON.parse(content);
+        const routeEvent = events.find((e) => e.eventType === "routing");
+        if (routeEvent && routeEvent.data?.request) {
+          return routeEvent.data.request;
+        }
+        const startEvent = events.find((e) => e.eventType === "implementation_start");
+        if (startEvent && startEvent.data?.prompt) {
+          return startEvent.data.prompt;
+        }
+      } catch {
+      }
+    }
+    try {
+      const dir = path3.join(this.cwd, ".ai-workflow/history");
+      const files = await fs3.readdir(dir);
+      for (const file of files) {
+        if (file.endsWith("-ledger.json")) {
+          const content = await fs3.readFile(path3.join(dir, file), "utf8");
+          const events = JSON.parse(content);
+          const routeEvent = events.find((e) => e.eventType === "routing");
+          if (routeEvent && routeEvent.data?.request) {
+            return routeEvent.data.request;
+          }
+        }
+      }
+    } catch {
+    }
+    try {
+      const { execSync: execSync2 } = await import("child_process");
+      const branch = execSync2("git branch --show-current", { cwd: this.cwd, encoding: "utf8" }).trim();
+      if (branch && branch !== "main" && branch !== "master" && branch.startsWith("feat/")) {
+        return branch.replace("feat/", "").replaceAll("-", " ");
+      }
+    } catch {
+    }
+    return "";
+  }
+  runTask(task) {
+    const kind = inferTaskKind(task);
+    if (task.presetStatus) {
+      return { name: task.name, command: task.command, kind, status: task.presetStatus, exitCode: null, summary: task.summary || "", output: "" };
+    }
+    let cmd = task.command;
+    let args = [];
+    if (Array.isArray(cmd)) {
+      const [c, ...a] = cmd;
+      cmd = c;
+      args = a;
+    } else if (typeof cmd === "string") {
+      const parts = cmd.split(/\s+/);
+      cmd = parts[0];
+      args = parts.slice(1);
+    }
+    const isWin32 = process.platform === "win32";
+    const isUncPath = typeof this.cwd === "string" && (this.cwd.startsWith("\\\\") || this.cwd.startsWith("//"));
+    const shellOption = isWin32 && isUncPath ? "powershell.exe" : isWin32 ? true : false;
+    const result = spawnSync(cmd, args, {
+      cwd: this.cwd,
+      shell: shellOption,
+      encoding: "utf8",
+      timeout: this.timeout
+    });
+    let status = result.status === 0 ? "PASS" : "FAIL";
+    if (result.error) {
+      status = "FAIL";
+      if (result.error.code === "ETIMEDOUT") {
+        status = "BLOCKED";
+      }
+    }
+    let summary = status === "PASS" ? "Command completed successfully." : "Command failed.";
+    if (result.error?.code === "ETIMEDOUT") {
+      summary = `Command timed out after ${this.timeout / 1e3}s.`;
+    } else if (result.error) {
+      summary = `Command execution error: ${result.error.message}`;
+    }
+    const rawOutput = `${result.stdout || ""}${result.stderr || ""}`.trim();
+    const output = rawOutput.length > this.maxLogLength ? `${rawOutput.slice(0, this.maxLogLength)}
+... [TRUNCATED]` : rawOutput;
+    return { name: task.name, command: task.command, kind, status, exitCode: result.status, signal: result.signal, summary, output };
+  }
+  async collect(tasks, { writeArtifact = false } = {}) {
+    const qualityGuard = new QualityGuard({ cwd: this.cwd, taskSlug: this.taskSlug, evidencePolicy: this.evidencePolicy, riskLevel: this.evidencePolicy === "required" ? "high" : "medium", evidenceWillBePersisted: writeArtifact });
+    const implementation = qualityGuard.isImplementationTask();
+    const executableBehavior = await qualityGuard.hasExecutableBehaviorChanges();
+    const results = tasks.map((task) => this.runTask(task));
+    const policyValidation = await qualityGuard.verify();
+    const behaviorTests = results.filter((result) => result.kind === "test");
+    const passingBehaviorTest = behaviorTests.some((result) => result.status === "PASS");
+    const userRequest = await this.findUserRequest();
+    const engine = new DeliveryDecisionEngine({ cwd: this.cwd });
+    const projectContext = await engine.detectContext();
+    const deliveryDecision = await engine.determineDecision({
+      userRequest,
+      projectContext,
+      explicitApprovals: this.explicitApprovals || []
+    });
+    const fidelityGate = new ArtifactFidelityGate({
+      cwd: this.cwd,
+      deliveryClass: deliveryDecision.allowedArtifactShape === "runnable-framework-app" ? "framework-native-frontend" : deliveryDecision.allowedArtifactShape === "wordpress" ? "wordpress-php" : "generic-code",
+      userRequest,
+      explicitApprovals: this.explicitApprovals || []
+    });
+    const changedFiles = policyValidation.git?.changedFiles || [];
+    const artifactFidelityCheck = await fidelityGate.verifyRequestFidelity({
+      userRequest,
+      deliveryDecision,
+      projectContext,
+      changedFiles
+    });
+    let overallStatus = "PASS";
+    if (implementation && executableBehavior && tasks.length === 0) overallStatus = "BLOCKED";
+    else if (results.some((result) => ["FAIL", "BLOCKED", "FAIL_QUALITY_GATE"].includes(result.status))) overallStatus = "FAIL_QUALITY_GATE";
+    else if (executableBehavior && !passingBehaviorTest) overallStatus = "BLOCKED";
+    else if (["FAIL", "BLOCKED", "FAIL_QUALITY_GATE"].includes(policyValidation.overallStatus)) overallStatus = "FAIL_QUALITY_GATE";
+    else if (results.some((result) => result.status === "PASS_WITH_NOTES") || policyValidation.overallStatus === "PASS_WITH_NOTES") overallStatus = "PASS_WITH_NOTES";
+    if (!artifactFidelityCheck || !artifactFidelityCheck.passed) {
+      overallStatus = "BLOCKED";
+    } else if (implementation) {
+      if (!deliveryDecision || !deliveryDecision.decision || deliveryDecision.decision.startsWith("BLOCK") || deliveryDecision.decision.includes("BLOCKED") || deliveryDecision.decision === "REQUIRE_EXPLICIT_AUTHORIZATION" || deliveryDecision.decision === "RELEASE_OR_DEPLOY_REQUIRES_APPROVAL") {
+        overallStatus = "BLOCKED";
+      } else if (results.length === 0 && executableBehavior && deliveryDecision.decision !== "DOCUMENTATION_ONLY" && deliveryDecision.decision !== "DOCS_ONLY" && deliveryDecision.decision !== "READ_ONLY_AUDIT") {
+        overallStatus = "BLOCKED";
+      }
+    }
+    const limitations = [];
+    if (implementation && executableBehavior && tasks.length === 0) limitations.push("No meaningful validation command was available for executable implementation work.");
+    if (executableBehavior && behaviorTests.length === 0) {
+      limitations.push("Executable behavior changed without a proportional automated behavior test. Build, lint, typecheck, smoke, screenshots, and manual review do not replace behavior tests.");
+    }
+    for (const [name, check] of Object.entries(policyValidation.checks || {})) {
+      if (check.status === "PASS_WITH_NOTES" && check.reason) limitations.push(`${name}: ${check.reason}`);
+    }
+    let visualEvidence = null;
+    if (this.visualDist) {
+      console.log(`
+--- Capturing Visual Evidence ---`);
+      console.log(`Serving ${this.visualDist} on port ${this.port}...`);
+      try {
+        const verifier = new VisualVerifier({ cwd: this.cwd, visualDist: this.visualDist, port: this.port });
+        const screenshots = await verifier.captureScreenshots();
+        visualEvidence = {
+          desktop: path3.relative(this.cwd, screenshots[0]),
+          mobile: path3.relative(this.cwd, screenshots[1])
+        };
+        console.log(`Visual evidence captured successfully:`);
+        console.log(`- Desktop: ${visualEvidence.desktop}`);
+        console.log(`- Mobile: ${visualEvidence.mobile}`);
+      } catch (err) {
+        console.error(`Error capturing visual evidence: ${err.message}`);
+        throw err;
+      }
+    }
+    const evidence = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      taskSlug: this.taskSlug,
+      executionMode: this.mode,
+      workflowProfile: this.profile,
+      branchRecovery: this.branchRecovery,
+      branch: policyValidation.git?.branch || "unknown",
+      changedFiles,
+      status: publicStatus(overallStatus),
+      internalStatus: overallStatus,
+      commands: results,
+      checks: policyValidation.checks,
+      limitations,
+      deliveryDecision,
+      artifactFidelityCheck,
+      visualEvidence
+    };
+    if (writeArtifact) {
+      await fs3.writeFile(path3.join(this.cwd, "EVIDENCE.json"), JSON.stringify(evidence, null, 2));
+    }
+    return evidence;
+  }
+};
+
+// src/core/validation/validation-planner.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+var ValidationPlanner = class {
+  cwd;
+  qualityGuard;
+  stackDetector;
+  constructor({ cwd = process.cwd(), qualityGuard }) {
+    this.cwd = cwd;
+    this.qualityGuard = qualityGuard;
+    this.stackDetector = new StackDetector({ cwd });
+  }
+  async plan(profile = "generic") {
+    const stacks = await this.stackDetector.detect();
+    const tasks = [];
+    const changedFiles = this.qualityGuard.getChangedFiles().filter((file) => {
+      return !/(^|\/)(node_modules|vendor|dist|coverage|\.cache)(\/|$)/.test(String(file).replaceAll("\\", "/"));
+    });
+    const executableBehavior = await this.qualityGuard.hasExecutableBehaviorChanges();
+    if (stacks.includes("node")) {
+      try {
+        const pkg = JSON.parse(await fs4.readFile(path4.join(this.cwd, "package.json"), "utf8"));
+        const scripts = pkg.scripts || {};
+        this.addNodeScriptTask(tasks, scripts, "lint", ["npm", "run", "lint"]);
+        this.addNodeScriptTask(tasks, scripts, "test", ["npm", "test"], { rejectNoOp: executableBehavior });
+        this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
+        this.addNodeScriptTask(tasks, scripts, "typecheck", ["npm", "run", "typecheck"]);
+        if (scripts.validate && !String(scripts.validate).includes("ai-workflow collect-evidence")) {
+          this.addNodeScriptTask(tasks, scripts, "validate", ["npm", "run", "validate"]);
+        }
+        const hasTs = changedFiles.some((file) => /\.(ts|tsx)$/.test(file)) || await fs4.access(path4.join(this.cwd, "tsconfig.json")).then(() => true).catch(() => false);
+        if (hasTs && !scripts.typecheck) {
+          tasks.push({
+            name: "typecheck",
+            command: ["npm", "run", "typecheck"],
+            kind: "typecheck",
+            presetStatus: "FAIL_QUALITY_GATE",
+            summary: "TypeScript detected but no typecheck script is configured."
+          });
+        }
+      } catch {
+      }
+    }
+    if (stacks.includes("python")) {
+      const pythonFiles = changedFiles.filter((f) => f.endsWith(".py"));
+      if (pythonFiles.length > 0) {
+        tasks.push({
+          name: "python-syntax",
+          command: ["python", "-m", "py_compile", ...pythonFiles],
+          kind: "lint"
+        });
+      }
+      if (executableBehavior) {
+        const hasPytestConfig = await fs4.access(path4.join(this.cwd, "pytest.ini")).then(() => true).catch(() => false) || await fs4.access(path4.join(this.cwd, "pyproject.toml")).then(() => true).catch(() => false);
+        if (hasPytestConfig || pythonFiles.length > 0) {
+          tasks.push({
+            name: "python-test",
+            command: ["pytest"],
+            kind: "test"
+          });
+        }
+      }
+    }
+    if (stacks.includes("php")) {
+      const phpFiles = changedFiles.filter((f) => f.endsWith(".php") || f.endsWith(".inc"));
+      if (phpFiles.length > 0) {
+        for (const file of phpFiles) {
+          tasks.push({
+            name: `php-syntax:${file}`,
+            command: ["php", "-l", file],
+            kind: "lint"
+          });
+        }
+      }
+      if (executableBehavior) {
+        const hasPhpUnitXml = await fs4.access(path4.join(this.cwd, "phpunit.xml")).then(() => true).catch(() => false) || await fs4.access(path4.join(this.cwd, "phpunit.xml.dist")).then(() => true).catch(() => false);
+        if (hasPhpUnitXml || phpFiles.length > 0) {
+          tasks.push({
+            name: "php-test",
+            command: ["vendor/bin/phpunit"],
+            kind: "test"
+          });
+        }
+      }
+    }
+    return tasks;
+  }
+  addNodeScriptTask(tasks, scripts, name, command, { rejectNoOp = false } = {}) {
+    const script = scripts[name];
+    if (!script) return;
+    if (!rejectNoOp && name === "test" && this.isNoOpScript(script)) return;
+    if (rejectNoOp && this.isNoOpScript(script)) {
+      tasks.push({
+        name,
+        command,
+        kind: name === "test" ? "test" : name,
+        presetStatus: "FAIL_QUALITY_GATE",
+        summary: `Configured ${name} script is a no-op: ${script}`
+      });
+      return;
+    }
+    tasks.push({ name, command, kind: name === "test" ? "test" : name });
+  }
+  isNoOpScript(script = "") {
+    const value = String(script).trim().toLowerCase();
+    return /^(echo\b|true$|exit\s+0$|node\s+-e\s+["']?console\.log)/.test(value) || value.includes("tests-pass");
+  }
+};
+
+export {
+  QualityGuard,
+  VisualVerifier,
+  EvidenceCollector,
+  ValidationPlanner
+};
+//# sourceMappingURL=chunk-6EMG6FAO.js.map