playwright-intelligence-engine 2.0.5 → 2.1.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/core/version.ts
 import { execFileSync } from "child_process";
-var PACKAGE_VERSION = "2.0.5";
-var ENGINE_MILESTONE = "2.0.5";
+var PACKAGE_VERSION = "2.1.0";
+var ENGINE_MILESTONE = "2.1.0";
 var PROOF_VERSION = ENGINE_MILESTONE;
 function getRuntimeProvenance(root = process.cwd()) {
   try {
@@ -153,8 +153,8 @@ var UnsupportedTraceVersionError = class extends PlaywrightIntelligenceError {
   }
 };
 var TraceCorruptedError = class extends PlaywrightIntelligenceError {
-  constructor(path32, reason) {
-    super(`Trace archive at ${path32} is corrupted: ${reason}`, "TRACE_CORRUPTED");
+  constructor(path33, reason) {
+    super(`Trace archive at ${path33} is corrupted: ${reason}`, "TRACE_CORRUPTED");
     this.name = "TraceCorruptedError";
   }
 };
@@ -244,16 +244,23 @@ var ArchiveReader = class _ArchiveReader {
         const text = entry.getData().toString("utf8");
         const lines = text.split(/\r?\n/);
         let failureScore = 0;
+        let hasRealError = false;
         for (const line of lines) {
           if (!line.includes('"type":"')) continue;
-          if (line.includes('"type":"after"') && line.includes('"error"')) failureScore += 100;
-          if (line.includes('"type":"error"') && (line.includes('"message"') || line.includes('"error"'))) failureScore += 80;
+          if (line.includes('"type":"after"') && line.includes('"error"')) {
+            failureScore += 100;
+            hasRealError = true;
+          }
+          if (line.includes('"type":"error"') && (line.includes('"message"') || line.includes('"error"'))) {
+            failureScore += 80;
+            hasRealError = true;
+          }
           if (line.includes('"type":"log"')) failureScore += 1;
         }
         if (path.basename(entry.entryName).toLowerCase() === "test.trace" && failureScore > 0) {
           failureScore += 10;
         }
-        return { entry, failureScore };
+        return { entry, failureScore, hasRealError };
       }).sort((a, b) => b.failureScore - a.failureScore || b.entry.header.size - a.entry.header.size);
       const orderedTraceNames = traceCandidates.map(({ entry }) => entry.entryName);
       const bestTrace = orderedTraceNames[0];
@@ -272,13 +279,15 @@ var ArchiveReader = class _ArchiveReader {
         const prefixMatch = networkCandidates.find((e) => path.basename(e.entryName, ".network").startsWith(workerPrefix));
         bestNetwork = prefixMatch ? prefixMatch.entryName : networkCandidates.sort((a, b) => b.header.size - a.header.size)[0]?.entryName;
       }
-      const topFailureScore = traceCandidates[0]?.failureScore ?? 0;
+      const topCandidate = traceCandidates[0];
+      const hasFailure = Boolean(topCandidate?.hasRealError);
+      const topFailureScore = topCandidate?.failureScore ?? 0;
       return {
         traceEntryName: bestTrace,
         networkEntryName: bestNetwork,
         traceEntryNames: orderedTraceNames,
         networkEntryNames,
-        hasFailure: topFailureScore > 0,
+        hasFailure,
         failureScore: topFailureScore
       };
     } catch {
@@ -522,13 +531,25 @@ var SnapshotResolver = class _SnapshotResolver {
     const role = attributes["role"] ?? _SnapshotResolver.inferRoleFromTag(tag, attributes);
     const inputValue = tag === "input" ? attributes["value"] ?? attributes["__playwright_value_"] : void 0;
     const accessibleName = attributes["aria-label"] ?? attributes["alt"] ?? attributes["title"] ?? attributes["placeholder"] ?? inputValue ?? textAccumulator.trim();
+    let boundingBox;
+    const boxAttr = attributes["data-bbox"] ?? attributes["__playwright_box_"] ?? attributes["data-box"];
+    if (boxAttr) {
+      try {
+        const parts = boxAttr.split(",").map(Number);
+        if (parts.length === 4 && parts.every((p) => !isNaN(p))) {
+          boundingBox = { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
+        }
+      } catch {
+      }
+    }
     return {
       tag,
       attributes,
       text: textAccumulator.trim(),
       children,
       role,
-      accessibleName: accessibleName || void 0
+      accessibleName: accessibleName || void 0,
+      boundingBox
     };
   }
   /**
@@ -601,13 +622,25 @@ var SnapshotResolver = class _SnapshotResolver {
     const role = attributes["role"] ?? _SnapshotResolver.inferRoleFromTag(tag, attributes);
     const inputValue = tag === "input" ? attributes["value"] ?? attributes["__playwright_value_"] : void 0;
     const accessibleName = attributes["aria-label"] ?? attributes["alt"] ?? attributes["title"] ?? attributes["placeholder"] ?? inputValue ?? textAccumulator.trim();
+    let boundingBox;
+    const boxAttr = attributes["data-bbox"] ?? attributes["__playwright_box_"] ?? attributes["data-box"];
+    if (boxAttr) {
+      try {
+        const parts = boxAttr.split(",").map(Number);
+        if (parts.length === 4 && parts.every((p) => !isNaN(p))) {
+          boundingBox = { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
+        }
+      } catch {
+      }
+    }
     return {
       tag,
       attributes,
       text: textAccumulator.trim(),
       children,
       role,
-      accessibleName: accessibleName || void 0
+      accessibleName: accessibleName || void 0,
+      boundingBox
     };
   }
   /**
@@ -3398,6 +3431,12 @@ var LocatorDisambiguationEngine = class {
         return landmarkResult;
       }
     }
+    if (context.targetBoundingBox) {
+      const spatialResult = this.attemptSpatialDisambiguation(candidates, context.targetBoundingBox, pageProperty);
+      if (spatialResult) {
+        return spatialResult;
+      }
+    }
     const hasExplicitPositionalIntent = this.verifyExplicitPositionalIntent(context);
     if (hasExplicitPositionalIntent) {
       const candidate = candidates[0];
@@ -3442,10 +3481,10 @@ var LocatorDisambiguationEngine = class {
     if (!context.rootDom) return null;
     const candidatePaths = candidates.map((c) => this.findPathToElement(context.rootDom, c));
     for (let cIdx = 0; cIdx < candidates.length; cIdx++) {
-      const path32 = candidatePaths[cIdx];
-      if (!path32 || path32.length < 2) continue;
-      for (let i = path32.length - 2; i >= 0; i--) {
-        const container = path32[i];
+      const path33 = candidatePaths[cIdx];
+      if (!path33 || path33.length < 2) continue;
+      for (let i = path33.length - 2; i >= 0; i--) {
+        const container = path33[i];
         const isContainer = container.tag === "tr" || container.tag === "li" || container.tag === "article" || container.tag === "section" || (container.attributes["data-testid"] ?? "").includes("card") || (container.attributes["data-testid"] ?? "").includes("item") || (container.attributes["class"] ?? "").includes("card") || (container.attributes["class"] ?? "").includes("item") || container.role === "row" || container.role === "listitem";
         if (isContainer) {
           const containerText = this.getCleanText(container);
@@ -3488,8 +3527,8 @@ var LocatorDisambiguationEngine = class {
     for (const landmark of landmarks) {
       if (textToCheck.includes(landmark)) {
         const candidatesInLandmark = candidates.filter((candidate) => {
-          const path32 = this.findPathToElement(context.rootDom, candidate);
-          return Boolean(path32 && path32.some((el) => el.tag === landmark || el.role === landmark));
+          const path33 = this.findPathToElement(context.rootDom, candidate);
+          return Boolean(path33 && path33.some((el) => el.tag === landmark || el.role === landmark));
         });
         if (candidatesInLandmark.length === 1) {
           const candidate = candidatesInLandmark[0];
@@ -3549,6 +3588,35 @@ var LocatorDisambiguationEngine = class {
     }
     return null;
   }
+  static attemptSpatialDisambiguation(candidates, targetBox, pageProperty) {
+    const candidatesWithBoxes = candidates.filter((c) => c.boundingBox !== void 0);
+    if (candidatesWithBoxes.length === 0) return void 0;
+    const targetCenterX = targetBox.x + targetBox.width / 2;
+    const targetCenterY = targetBox.y + targetBox.height / 2;
+    const scored = candidatesWithBoxes.map((c) => {
+      const box = c.boundingBox;
+      const candCenterX = box.x + box.width / 2;
+      const candCenterY = box.y + box.height / 2;
+      const distance = Math.hypot(targetCenterX - candCenterX, targetCenterY - candCenterY);
+      const sizeDiff = Math.abs(targetBox.width - box.width) + Math.abs(targetBox.height - box.height);
+      return { candidate: c, distance, sizeDiff, totalScore: distance + sizeDiff * 0.5 };
+    }).sort((a, b) => a.totalScore - b.totalScore);
+    const best = scored[0];
+    const secondBest = scored[1];
+    if (best && (!secondBest || secondBest.distance - best.distance > 20 || best.distance < 15)) {
+      const baseExpr = CandidateExtractor.generateLocator(best.candidate, pageProperty);
+      return {
+        strategy: "SPATIAL_COORDINATE_MATCH",
+        resolvedCandidate: best.candidate,
+        resolvedExpression: baseExpr,
+        matchCount: candidates.length,
+        explanation: `Disambiguated via spatial layout coordinates: candidate element aligns with target coordinates within ${best.distance.toFixed(1)}px distance.`,
+        confidence: 0.94,
+        isUnique: true
+      };
+    }
+    return void 0;
+  }
   static getCleanText(el) {
     if (el.text && el.text.trim().length > 0) {
       return el.text.trim();
@@ -3565,7 +3633,7 @@ var LocatorDisambiguationEngine = class {
 
 // src/selector/repair-candidate-ranker.ts
 var RepairCandidateRanker = class {
-  static rank(candidates, originalSelector, intendedAction, intelligence, rootDom, testIntentText) {
+  static rank(candidates, originalSelector, intendedAction, intelligence, rootDom, testIntentText, targetBoundingBox) {
     const projectContext = intelligence?.profile ? {
       preferredLocator: intelligence.profile.locatorConventions.preferred,
       locatorUsage: {
@@ -3578,7 +3646,7 @@ var RepairCandidateRanker = class {
     } : void 0;
     const disambiguation = candidates.length > 1 ? LocatorDisambiguationEngine.disambiguate(
       candidates,
-      { originalSelector, intendedAction, rootDom, testIntentText },
+      { originalSelector, intendedAction, rootDom, testIntentText, targetBoundingBox },
       "page"
     ) : void 0;
     return candidates.flatMap((candidate) => {
@@ -4057,14 +4125,14 @@ var EvidenceRedactor = class _EvidenceRedactor {
   static redactPayload(payload) {
     const redactedFields = [];
     const rulesApplied = [];
-    function recurse(value, path32) {
+    function recurse(value, path33) {
       if (value === null || value === void 0) {
         return value;
       }
       if (typeof value === "string") {
         const { redactedText, rulesApplied: applied } = _EvidenceRedactor.redactText(value);
         if (applied.length > 0) {
-          redactedFields.push(path32);
+          redactedFields.push(path33);
           for (const rule of applied) {
             if (!rulesApplied.includes(rule)) rulesApplied.push(rule);
           }
@@ -4072,12 +4140,12 @@ var EvidenceRedactor = class _EvidenceRedactor {
         return redactedText;
       }
       if (Array.isArray(value)) {
-        return value.map((item, idx) => recurse(item, `${path32}[${idx}]`));
+        return value.map((item, idx) => recurse(item, `${path33}[${idx}]`));
       }
       if (typeof value === "object") {
         const result = {};
         for (const [k, v] of Object.entries(value)) {
-          const currentPath = path32 ? `${path32}.${k}` : k;
+          const currentPath = path33 ? `${path33}.${k}` : k;
           const isSensitiveField = _EvidenceRedactor.SENSITIVE_FIELD_PATTERNS.some((p) => p.test(k));
           if (isSensitiveField) {
             result[k] = "[REDACTED]";
@@ -7937,6 +8005,19 @@ async function listSourceFiles2(root, depth = 0) {
 function normalize(value) {
   return value.replace(/\s+/g, "").replace(/;$/, "");
 }
+function extractInternalSelectorValues(selector) {
+  const values = [];
+  if (!selector.startsWith("internal:")) return values;
+  const quoted = selector.matchAll(/(?:name|text|label|testid|placeholder)=["']([^"']+)["']/gi);
+  for (const m of quoted) {
+    if (m[1]) values.push(m[1]);
+  }
+  const unquoted = selector.matchAll(/(?:name|text|label|testid|placeholder)=([^\]\s]+)/gi);
+  for (const m of unquoted) {
+    if (m[1] && !m[1].startsWith('"') && !m[1].startsWith("'")) values.push(m[1].replace(/i$/, ""));
+  }
+  return values;
+}
 function selectorMatches(selector, locator) {
   const wanted = normalize(selector);
   const source = normalize(locator.selectorText);
@@ -7944,6 +8025,13 @@ function selectorMatches(selector, locator) {
   if (source.includes(wanted)) {
     return { score: 100, evidence: ["Failed selector expression matched a Page Object locator expression"] };
   }
+  const internalValues = extractInternalSelectorValues(selector);
+  for (const val of internalValues) {
+    const normVal = normalize(val);
+    if (normVal && source.includes(normVal)) {
+      return { score: 95, evidence: [`Failed internal selector value '${val}' matched a Page Object locator expression`] };
+    }
+  }
   const argumentMatch = source.match(/(?:locator|getByRole|getByText|getByTestId|getByLabel|getByPlaceholder|getByAltText|getByTitle)\((.*)\)/);
   if (argumentMatch?.[1] && (argumentMatch[1].includes(wanted) || wanted.includes(argumentMatch[1]))) {
     return { score: 80, evidence: ["Failed selector value matched a Page Object locator argument"] };
@@ -7967,8 +8055,8 @@ function resolveTestSourcePath(root, sourceFiles, sourceFile) {
     return wanted.endsWith(`/${candidate}`) || candidate.endsWith(`/${wanted}`) || candidate === wanted;
   });
   if (suffixMatches.length === 1 && suffixMatches[0]) return { path: suffixMatches[0], remapped: true };
-  const basename = path14.basename(sourceFile).toLowerCase();
-  const basenameMatches = sourceFiles.filter((file) => path14.basename(file).toLowerCase() === basename);
+  const basename2 = path14.basename(sourceFile).toLowerCase();
+  const basenameMatches = sourceFiles.filter((file) => path14.basename(file).toLowerCase() === basename2);
   return basenameMatches.length === 1 && basenameMatches[0] ? { path: basenameMatches[0], remapped: true } : { remapped: false };
 }
 async function discoverRepairSourceMapping(input) {
@@ -7987,7 +8075,9 @@ async function discoverRepairSourceMapping(input) {
     } catch {
       continue;
     }
-    if (!normalize(sourceText).includes(normalizedSelector)) continue;
+    const internalValues = extractInternalSelectorValues(selector);
+    const hasMatchInSource = normalize(sourceText).includes(normalizedSelector) || internalValues.some((val) => normalize(sourceText).includes(normalize(val)));
+    if (!hasMatchInSource) continue;
     const result = await new StaticAstCollector().collect({ targetFilePath: filePath });
     const payload = result[0]?.payload;
     if (!payload?.isPageObject || !payload.locators) continue;
@@ -15268,6 +15358,353 @@ async function runAutonomousRepairWorkflow(input) {
   };
 }
 
+// src/intelligence/batch-repair-workflow.ts
+import fs27 from "fs/promises";
+import fsSync5 from "fs";
+import path26 from "path";
+import crypto9 from "crypto";
+function discoverFailingTraces(workspaceRoot) {
+  const candidateDirs = [
+    path26.resolve(workspaceRoot, "test-results"),
+    path26.resolve(workspaceRoot, "playwright-report"),
+    path26.resolve(workspaceRoot)
+  ];
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of candidateDirs) {
+    if (!fsSync5.existsSync(dir)) continue;
+    try {
+      const entries = fsSync5.readdirSync(dir, { recursive: true });
+      for (const entry of entries) {
+        const fullPath = path26.join(dir, String(entry));
+        if (fullPath.endsWith(".zip") && !seen.has(fullPath)) {
+          try {
+            const stat = fsSync5.statSync(fullPath);
+            if (stat.isFile()) {
+              seen.add(fullPath);
+              let hasFailure = false;
+              try {
+                const discovery = ArchiveReader.findTraceFileEntries(fullPath);
+                hasFailure = Boolean(discovery.hasFailure);
+              } catch {
+              }
+              const isTestResults = fullPath.includes("test-results");
+              found.push({ filePath: fullPath, mtime: stat.mtimeMs, hasFailure, isTestResults });
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const testResultsFailing = found.filter((f) => f.isTestResults && f.hasFailure);
+  const failing = testResultsFailing.length > 0 ? testResultsFailing : found.filter((f) => f.hasFailure);
+  const pool = failing.length > 0 ? failing : found;
+  return pool.sort((a, b) => {
+    if (a.hasFailure !== b.hasFailure) return a.hasFailure ? -1 : 1;
+    if (a.isTestResults !== b.isTestResults) return a.isTestResults ? -1 : 1;
+    return b.mtime - a.mtime;
+  }).map((f) => f.filePath);
+}
+async function runBatchRepairWorkflow(input) {
+  const workspaceRoot = path26.resolve(input.workspaceRoot ?? process.cwd());
+  const tracePaths = input.tracePaths && input.tracePaths.length > 0 ? input.tracePaths.map((p) => path26.resolve(workspaceRoot, p)) : discoverFailingTraces(workspaceRoot);
+  if (tracePaths.length === 0) {
+    return {
+      status: "ABSTAINED",
+      totalTraces: 0,
+      repairedCount: 0,
+      abstainedCount: 0,
+      failedCount: 0,
+      items: [],
+      clusters: [],
+      executionPassed: true,
+      promotedFiles: []
+    };
+  }
+  const items = [];
+  const failureObservations = [];
+  const intelligence = await bootstrapProjectIntelligence(workspaceRoot);
+  for (const tracePath of tracePaths) {
+    try {
+      const proposalRun = await runTraceProposalWorkflow({
+        tracePath,
+        workspaceRoot,
+        enableBrowserInvestigation: input.enableBrowserInvestigation,
+        browserUrl: input.browserUrl,
+        browserAllowedHosts: input.browserAllowedHosts,
+        enableTestExecution: input.enableTestExecution
+      });
+      const { correlated, agent } = proposalRun;
+      const category = correlated.classification.category;
+      const confidence = correlated.classification.confidence;
+      const testTitle = correlated.context.failedAction.sourceFile ? path26.basename(correlated.context.failedAction.sourceFile) : "Unknown Spec";
+      failureObservations.push({
+        id: path26.basename(tracePath, ".zip"),
+        repository: path26.basename(workspaceRoot),
+        testTitle,
+        sourceFile: correlated.context.failedAction.sourceFile,
+        category,
+        action: correlated.context.failedAction.action,
+        selector: correlated.context.failedAction.selector,
+        errorMessage: correlated.context.failedAction.errorStack?.split("\n")[0] ?? correlated.context.failedAction.action,
+        errorStack: correlated.context.failedAction.errorStack,
+        tracePath
+      });
+      if (correlated.classification.shouldAbstain) {
+        items.push({
+          tracePath,
+          testTitle,
+          status: "ABSTAINED",
+          category,
+          confidence,
+          reason: correlated.classification.abstentionReason ?? correlated.classification.reason ?? "Abstained by diagnostic policy",
+          failedTarget: correlated.context.failedAction.selector
+        });
+        continue;
+      }
+      if (!agent.proposal || agent.proposal.decision === "ABSTAIN") {
+        items.push({
+          tracePath,
+          testTitle,
+          status: "ABSTAINED",
+          category,
+          confidence,
+          reason: agent.proposal?.reasoningSummary ?? agent.errors.join("; ") ?? "Proposal abstained",
+          failedTarget: correlated.context.failedAction.selector
+        });
+        continue;
+      }
+      const selected = DiagnosticReportGenerator.selectRepairCandidate(correlated, intelligence);
+      const proposedLocator = selected?.locatorExpression ?? agent.proposal.operations[0]?.locator;
+      const failedTarget = correlated.context.failedAction.selector ?? agent.proposal.operations[0]?.target;
+      if (!proposedLocator) {
+        items.push({
+          tracePath,
+          testTitle,
+          status: "ABSTAINED",
+          category,
+          confidence,
+          reason: "No unique candidate locator survived ranking and abstention gates",
+          failedTarget
+        });
+        continue;
+      }
+      const mapping = await discoverRepairSourceMapping({
+        workspaceRoot,
+        failedAction: correlated.context.failedAction
+      });
+      if (mapping) {
+        items.push({
+          tracePath,
+          testTitle,
+          status: "PROPOSAL_READY",
+          category,
+          confidence,
+          reason: agent.proposal.reasoningSummary,
+          failedTarget,
+          healedLocator: proposedLocator,
+          targetFilePath: mapping.pomFilePath,
+          testFilePath: mapping.testFilePath,
+          className: mapping.className,
+          memberName: mapping.memberName,
+          pattern: "page-object",
+          proposal: agent.proposal
+        });
+      } else {
+        const sourceFile = correlated.context.failedAction.sourceFile;
+        const resolvedSpec = sourceFile ? path26.resolve(workspaceRoot, sourceFile) : void 0;
+        if (resolvedSpec && fsSync5.existsSync(resolvedSpec) && (resolvedSpec.includes(".spec.") || resolvedSpec.includes(".test."))) {
+          items.push({
+            tracePath,
+            testTitle,
+            status: "PROPOSAL_READY",
+            category,
+            confidence,
+            reason: agent.proposal.reasoningSummary,
+            failedTarget,
+            healedLocator: proposedLocator,
+            targetFilePath: resolvedSpec,
+            testFilePath: resolvedSpec,
+            pattern: "inline-locator",
+            proposal: agent.proposal
+          });
+        } else {
+          items.push({
+            tracePath,
+            testTitle,
+            status: "ABSTAINED",
+            category,
+            confidence,
+            reason: "Source mapping could not locate a unique Page Object or test file to patch",
+            failedTarget,
+            healedLocator: proposedLocator
+          });
+        }
+      }
+    } catch (err) {
+      items.push({
+        tracePath,
+        status: "FAILED",
+        category: "INTERNAL_ERROR",
+        confidence: 0,
+        reason: err?.message ?? String(err)
+      });
+    }
+  }
+  const clusters = clusterFailures(failureObservations);
+  const proposableItems = items.filter((item) => item.status === "PROPOSAL_READY");
+  if (proposableItems.length === 0 || !input.execute && !input.autoPromote) {
+    return {
+      status: proposableItems.length > 0 ? "PARTIAL" : items.every((i) => i.status === "ABSTAINED") ? "ABSTAINED" : "FAILED",
+      totalTraces: items.length,
+      repairedCount: 0,
+      abstainedCount: items.filter((i) => i.status === "ABSTAINED").length,
+      failedCount: items.filter((i) => i.status === "FAILED").length,
+      items,
+      clusters
+    };
+  }
+  const manager = new WorktreeManager(workspaceRoot);
+  const batchWorktreeId = input.worktreeId ?? `batch-repair-${crypto9.randomUUID().slice(0, 8)}`;
+  let worktree;
+  try {
+    worktree = await manager.createWorktree(batchWorktreeId);
+  } catch (err) {
+    return {
+      status: "FAILED",
+      totalTraces: items.length,
+      repairedCount: 0,
+      abstainedCount: items.filter((i) => i.status === "ABSTAINED").length,
+      failedCount: items.length,
+      items: items.map((i) => i.status === "PROPOSAL_READY" ? { ...i, status: "FAILED", reason: `Worktree creation failed: ${err.message}` } : i),
+      clusters
+    };
+  }
+  let executionPassed = false;
+  const promotedFiles = [];
+  const modifiedFileContents = /* @__PURE__ */ new Map();
+  try {
+    const byTargetFile = /* @__PURE__ */ new Map();
+    for (const item of proposableItems) {
+      if (!item.targetFilePath) continue;
+      const list = byTargetFile.get(item.targetFilePath) ?? [];
+      list.push(item);
+      byTargetFile.set(item.targetFilePath, list);
+    }
+    const astPatcher = new AstPatcher();
+    const statementPatcher = new StatementPatcher();
+    for (const [targetFile, targetItems] of byTargetFile.entries()) {
+      const relTarget = path26.relative(workspaceRoot, targetFile);
+      const worktreeTarget = path26.resolve(worktree.worktreePath, relTarget);
+      if (!fsSync5.existsSync(worktreeTarget)) {
+        for (const it of targetItems) {
+          it.status = "REJECTED";
+          it.reason = `Worktree target file does not exist: '${relTarget}'`;
+        }
+        continue;
+      }
+      let currentSource = await fs27.readFile(worktreeTarget, "utf8");
+      for (const item of targetItems) {
+        try {
+          if (item.pattern === "page-object" && item.className && item.memberName && item.healedLocator) {
+            const patchRes = astPatcher.patchPageObjectInMemory(currentSource, {
+              className: item.className,
+              memberName: item.memberName,
+              replacementExpression: item.healedLocator
+            });
+            currentSource = patchRes.patchedSource;
+            item.fullDiff = patchRes.diff;
+          } else if (item.pattern === "inline-locator" && item.failedTarget && item.healedLocator) {
+            const patchRes = statementPatcher.patchStatementInMemory(currentSource, {
+              kind: "replace-inline-locator",
+              oldLocatorText: item.failedTarget,
+              newLocatorExpression: item.healedLocator
+            }, path26.basename(relTarget));
+            currentSource = patchRes.patchedSource;
+            item.fullDiff = patchRes.diff;
+          }
+        } catch (patchErr) {
+          item.status = "REJECTED";
+          item.reason = `AST patching rejected: ${patchErr?.message ?? String(patchErr)}`;
+        }
+      }
+      let allAllowed = true;
+      for (const item of targetItems) {
+        if (item.healedLocator) {
+          const checkGrammar = DiffAllowlistValidator.validateLocatorGrammar(item.healedLocator);
+          if (!checkGrammar.isValid) {
+            item.status = "REJECTED";
+            item.reason = `Invalid locator grammar: ${checkGrammar.reason}`;
+            allAllowed = false;
+          }
+        }
+      }
+      if (!allAllowed) continue;
+      await fs27.writeFile(worktreeTarget, currentSource, "utf8");
+      modifiedFileContents.set(relTarget, currentSource);
+    }
+    const impactedSpecs = [...new Set(
+      proposableItems.filter((it) => it.status === "PROPOSAL_READY").map((it) => it.testFilePath).filter(Boolean)
+    )];
+    if (impactedSpecs.length > 0) {
+      const relSpecs = impactedSpecs.map((s) => path26.relative(workspaceRoot, s).replace(/\\/g, "/"));
+      const testArgs = ["playwright", "test", ...relSpecs, "--reporter=line"];
+      if (input.configPath) {
+        testArgs.push("--config", path26.relative(workspaceRoot, input.configPath).replace(/\\/g, "/"));
+      }
+      const execResult = await ExecutionRunner.run("npx", {
+        cwd: worktree.worktreePath,
+        args: testArgs,
+        timeoutMs: 12e4
+      });
+      const passedMatch = execResult.stdout.match(/(\d+)\s+passed/i);
+      const passedCount = passedMatch ? parseInt(passedMatch[1] ?? "0", 10) : 0;
+      executionPassed = execResult.exitCode === 0 && passedCount > 0 && !execResult.timedOut;
+      for (const it of proposableItems) {
+        if (it.status === "PROPOSAL_READY") {
+          it.status = executionPassed ? "VERIFIED" : "VERIFICATION_FAILED";
+          if (!executionPassed) {
+            it.reason = execResult.timedOut ? "Execution timed out in worktree" : `Worktree Playwright tests failed (exitCode=${execResult.exitCode})`;
+          }
+        }
+      }
+      if (executionPassed && input.autoPromote) {
+        for (const [relPath, content] of modifiedFileContents.entries()) {
+          const workspaceDest = path26.resolve(workspaceRoot, relPath);
+          await fs27.mkdir(path26.dirname(workspaceDest), { recursive: true });
+          await fs27.writeFile(workspaceDest, content, "utf8");
+          promotedFiles.push(relPath);
+        }
+        for (const it of proposableItems) {
+          if (it.status === "VERIFIED") {
+            it.status = "PROMOTED";
+          }
+        }
+      }
+    }
+  } finally {
+    await manager.destroyWorktree(batchWorktreeId);
+  }
+  const repairedCount = items.filter((i) => i.status === "VERIFIED" || i.status === "PROMOTED").length;
+  const abstainedCount = items.filter((i) => i.status === "ABSTAINED").length;
+  const failedCount = items.filter((i) => i.status === "FAILED" || i.status === "VERIFICATION_FAILED" || i.status === "REJECTED").length;
+  const status = repairedCount > 0 && failedCount === 0 ? "COMPLETED" : repairedCount > 0 ? "PARTIAL" : abstainedCount > 0 && repairedCount === 0 ? "ABSTAINED" : "FAILED";
+  return {
+    status,
+    totalTraces: items.length,
+    repairedCount,
+    abstainedCount,
+    failedCount,
+    items,
+    clusters,
+    worktree,
+    executionPassed,
+    promotedFiles
+  };
+}
+
 // src/intelligence/generation-agent.ts
 import { z as z11 } from "zod";
 
@@ -15732,13 +16169,13 @@ async function runGenerationAgent(input) {
 }
 
 // src/intelligence/generation-verifier.ts
-import fs27 from "fs/promises";
-import fsSync5 from "fs";
-import path26 from "path";
+import fs28 from "fs/promises";
+import fsSync6 from "fs";
+import path27 from "path";
 import { z as z13 } from "zod";
 
 // src/intelligence/workflow-planner.ts
-import crypto9 from "crypto";
+import crypto10 from "crypto";
 import { z as z12 } from "zod";
 var WorkflowProvenanceSchema = z12.enum([
   "explicit-requirement",
@@ -15816,7 +16253,7 @@ var GenerationWorkflowPlanSchema = z12.object({
   }).optional()
 });
 function stableHash(value) {
-  return crypto9.createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 12);
+  return crypto10.createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 12);
 }
 function computeWorkflowPlanHash(plan) {
   return stableHash({
@@ -16666,7 +17103,7 @@ export { expect } from '@playwright/test';
     });
     fixtureImportForSpec = `./fixtures/app.fixtures.js`;
   } else {
-    const relFromSpec = path26.posix.relative("tests", repoGraph.testImport).replace(/\.ts$/, ".js");
+    const relFromSpec = path27.posix.relative("tests", repoGraph.testImport).replace(/\.ts$/, ".js");
     fixtureImportForSpec = relFromSpec.startsWith(".") ? relFromSpec : `./${relFromSpec}`;
   }
   const testBlocks = [];
@@ -16785,22 +17222,22 @@ export default defineConfig({
 }
 function resolveWorkspaceCli(workspaceRoot, tool) {
   if (tool === "tsc") {
-    const jsEntry = path26.join(workspaceRoot, "node_modules", "typescript", "bin", "tsc");
-    if (fsSync5.existsSync(jsEntry)) {
+    const jsEntry = path27.join(workspaceRoot, "node_modules", "typescript", "bin", "tsc");
+    if (fsSync6.existsSync(jsEntry)) {
       return { cmd: process.execPath, prefixArgs: [jsEntry] };
     }
-    const binEntry = path26.join(workspaceRoot, "node_modules", ".bin", process.platform === "win32" ? "tsc.cmd" : "tsc");
-    if (fsSync5.existsSync(binEntry)) {
+    const binEntry = path27.join(workspaceRoot, "node_modules", ".bin", process.platform === "win32" ? "tsc.cmd" : "tsc");
+    if (fsSync6.existsSync(binEntry)) {
       return { cmd: "npx", prefixArgs: ["tsc"] };
     }
     return void 0;
   }
-  const pwJs = path26.join(workspaceRoot, "node_modules", "@playwright", "test", "cli.js");
-  if (fsSync5.existsSync(pwJs)) {
+  const pwJs = path27.join(workspaceRoot, "node_modules", "@playwright", "test", "cli.js");
+  if (fsSync6.existsSync(pwJs)) {
     return { cmd: process.execPath, prefixArgs: [pwJs] };
   }
-  const pwBin = path26.join(workspaceRoot, "node_modules", ".bin", process.platform === "win32" ? "playwright.cmd" : "playwright");
-  if (fsSync5.existsSync(pwBin)) {
+  const pwBin = path27.join(workspaceRoot, "node_modules", ".bin", process.platform === "win32" ? "playwright.cmd" : "playwright");
+  if (fsSync6.existsSync(pwBin)) {
     return { cmd: "npx", prefixArgs: ["playwright"] };
   }
   return void 0;
@@ -16814,16 +17251,16 @@ async function runCommandInWorkspace(cmd, args, cwd, timeoutMs = 6e4) {
   return { exitCode: res.exitCode ?? 1, stdout: res.stdout, stderr: res.stderr };
 }
 async function findFirstTraceZip(root) {
-  const candidates = [path26.join(root, "test-results"), path26.join(root, ".playwright-results")];
+  const candidates = [path27.join(root, "test-results"), path27.join(root, ".playwright-results")];
   for (const base of candidates) {
-    if (!fsSync5.existsSync(base)) continue;
-    const entries = await fs27.readdir(base, { withFileTypes: true }).catch(() => []);
+    if (!fsSync6.existsSync(base)) continue;
+    const entries = await fs28.readdir(base, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const traceFile = path26.join(base, entry.name, "trace.zip");
-        if (fsSync5.existsSync(traceFile)) return traceFile;
+        const traceFile = path27.join(base, entry.name, "trace.zip");
+        if (fsSync6.existsSync(traceFile)) return traceFile;
       } else if (entry.name.endsWith("trace.zip")) {
-        return path26.join(base, entry.name);
+        return path27.join(base, entry.name);
       }
     }
   }
@@ -16896,9 +17333,9 @@ function formatQaReportMarkdown(report) {
 `;
 }
 async function runEvidenceDrivenGeneration(input) {
-  const workspaceRoot = path26.resolve(input.workspaceRoot);
-  const artifactDir = path26.resolve(input.outArtifactDir ?? path26.join(workspaceRoot, ".pie"));
-  await fs27.mkdir(artifactDir, { recursive: true });
+  const workspaceRoot = path27.resolve(input.workspaceRoot);
+  const artifactDir = path27.resolve(input.outArtifactDir ?? path27.join(workspaceRoot, ".pie"));
+  await fs28.mkdir(artifactDir, { recursive: true });
   const repoGraph = await buildBrownfieldRepositoryGraph(workspaceRoot).catch(() => void 0);
   let workflowPlan = buildWorkflowPlan({
     ...input,
@@ -16915,12 +17352,12 @@ async function runEvidenceDrivenGeneration(input) {
       featureText = input.editedFeatureText;
     }
   }
-  const workflowPlanPath = path26.join(artifactDir, "workflow-plan.json");
-  const featureFilePath = path26.join(artifactDir, `${workflowPlan.slug}.feature`);
-  await fs27.writeFile(workflowPlanPath, `${JSON.stringify(workflowPlan, null, 2)}
+  const workflowPlanPath = path27.join(artifactDir, "workflow-plan.json");
+  const featureFilePath = path27.join(artifactDir, `${workflowPlan.slug}.feature`);
+  await fs28.writeFile(workflowPlanPath, `${JSON.stringify(workflowPlan, null, 2)}
 `, "utf8");
-  await fs27.writeFile(featureFilePath, featureText, "utf8");
-  const explorationBundlePath = path26.join(artifactDir, "exploration-evidence.json");
+  await fs28.writeFile(featureFilePath, featureText, "utf8");
+  const explorationBundlePath = path27.join(artifactDir, "exploration-evidence.json");
   const explorationBundle = await InteractiveWorkflowRunner.run({
     baseUrl: input.baseUrl,
     workspaceRoot,
@@ -17049,9 +17486,9 @@ async function runEvidenceDrivenGeneration(input) {
       modifiedFiles = writeRes.modified;
     }
   }
-  const targetTsconfig = path26.join(workspaceRoot, "tsconfig.json");
+  const targetTsconfig = path27.join(workspaceRoot, "tsconfig.json");
   const tscTool = resolveWorkspaceCli(workspaceRoot, "tsc");
-  if (input.write !== false && staticViolations.length === 0 && fsSync5.existsSync(targetTsconfig) && tscTool) {
+  if (input.write !== false && staticViolations.length === 0 && fsSync6.existsSync(targetTsconfig) && tscTool) {
     tscChecked = true;
     const tscRes = await runCommandInWorkspace(tscTool.cmd, [...tscTool.prefixArgs, "-p", targetTsconfig, "--noEmit"], workspaceRoot);
     tscPassed = tscRes.exitCode === 0;
@@ -17163,12 +17600,12 @@ async function runEvidenceDrivenGeneration(input) {
   if (input.runMutations !== false && execPassed && canRunPlaywright && pwTool) {
     mutationExecuted = true;
     for (const spec of specFiles) {
-      const targetPath = path26.resolve(workspaceRoot, spec.relativePath);
-      const original = await fs27.readFile(targetPath, "utf8");
+      const targetPath = path27.resolve(workspaceRoot, spec.relativePath);
+      const original = await fs28.readFile(targetPath, "utf8");
       const levelCMutants = buildAssertionMutants(spec.relativePath, original);
       for (const mut of levelCMutants) {
         try {
-          await fs27.writeFile(targetPath, mut.mutatedContent, "utf8");
+          await fs28.writeFile(targetPath, mut.mutatedContent, "utf8");
           const res = await runCommandInWorkspace(pwTool.cmd, [...pwTool.prefixArgs, "test", spec.relativePath, "--reporter=line"], workspaceRoot, 6e4);
           mutationEntries.push({
             id: mut.id,
@@ -17187,7 +17624,7 @@ async function runEvidenceDrivenGeneration(input) {
             status: "INVALID"
           });
         } finally {
-          await fs27.writeFile(targetPath, original, "utf8");
+          await fs28.writeFile(targetPath, original, "utf8");
         }
       }
       const hasApiEndpoints = explorationBundle.network.some((n) => n.url.includes("/api/"));
@@ -17201,7 +17638,7 @@ $1`) : original.replace(/(test\s*\()/, `${injected}
 $1`);
         if (mutatedApiContent !== original) {
           try {
-            await fs27.writeFile(targetPath, mutatedApiContent, "utf8");
+            await fs28.writeFile(targetPath, mutatedApiContent, "utf8");
             const res = await runCommandInWorkspace(pwTool.cmd, [...pwTool.prefixArgs, "test", spec.relativePath, "--reporter=line"], workspaceRoot, 6e4);
             mutationEntries.push({
               id: "mut-b-api-500",
@@ -17212,7 +17649,7 @@ $1`);
               exitCode: res.exitCode
             });
           } finally {
-            await fs27.writeFile(targetPath, original, "utf8");
+            await fs28.writeFile(targetPath, original, "utf8");
           }
         }
       }
@@ -17226,8 +17663,8 @@ $1`);
   const mutationScore = validTotal > 0 ? Number((killed / validTotal * 100).toFixed(2)) : null;
   const hasDefects = explorationBundle.findings.some((f) => f.category === "SPEC_VIOLATION" || f.category === "RUNTIME_ERROR");
   const finalStatus = staticViolations.length > 0 || executed && !execPassed ? "VERIFICATION_FAILED" : execPassed && (!hasDefects && (mutationScore === null || mutationScore >= 80)) ? "VERIFIED" : execPassed ? "VERIFIED_WITH_WARNINGS" : "GENERATED";
-  const qaReportJsonPath = path26.join(artifactDir, "qa-report.json");
-  const qaReportMarkdownPath = path26.join(artifactDir, "qa-report.md");
+  const qaReportJsonPath = path27.join(artifactDir, "qa-report.json");
+  const qaReportMarkdownPath = path27.join(artifactDir, "qa-report.md");
   const qaReport = {
     reportVersion: "1.0",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17308,9 +17745,9 @@ $1`);
       mcpDependenciesUsed: "none"
     }
   };
-  await fs27.writeFile(qaReportJsonPath, `${JSON.stringify(qaReport, null, 2)}
+  await fs28.writeFile(qaReportJsonPath, `${JSON.stringify(qaReport, null, 2)}
 `, "utf8");
-  await fs27.writeFile(qaReportMarkdownPath, formatQaReportMarkdown(qaReport), "utf8");
+  await fs28.writeFile(qaReportMarkdownPath, formatQaReportMarkdown(qaReport), "utf8");
   return {
     workflowPlan,
     featureText,
@@ -17321,9 +17758,9 @@ $1`);
 }
 
 // src/intelligence/suite-intelligence.ts
-import fs28 from "fs/promises";
-import fsSync6 from "fs";
-import path27 from "path";
+import fs29 from "fs/promises";
+import fsSync7 from "fs";
+import path28 from "path";
 function round(value) {
   return Number(value.toFixed(3));
 }
@@ -17377,14 +17814,14 @@ async function listTestFiles(root, depth = 0) {
   const ignored = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", "test-results", "playwright-report"]);
   let entries;
   try {
-    entries = await fs28.readdir(root, { withFileTypes: true });
+    entries = await fs29.readdir(root, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
     if (ignored.has(entry.name)) continue;
-    const fullPath = path27.join(root, entry.name);
+    const fullPath = path28.join(root, entry.name);
     if (entry.isDirectory()) files.push(...await listTestFiles(fullPath, depth + 1));
     else if (/\.(?:spec|test)\.(?:ts|tsx|js|jsx|mjs|cjs)$/i.test(entry.name)) files.push(fullPath);
   }
@@ -17393,7 +17830,7 @@ async function listTestFiles(root, depth = 0) {
 function resolveImport(root, sourceFile, specifier, aliases) {
   let base;
   if (specifier.startsWith(".")) {
-    base = path27.resolve(path27.dirname(sourceFile), specifier);
+    base = path28.resolve(path28.dirname(sourceFile), specifier);
   } else {
     const alias = aliases.find((candidate) => {
       if (candidate.pattern.includes("*")) {
@@ -17406,17 +17843,17 @@ function resolveImport(root, sourceFile, specifier, aliases) {
       const [prefix, suffix] = alias.pattern.split("*");
       const wildcard = alias.pattern.includes("*") ? specifier.slice((prefix ?? "").length, specifier.length - (suffix ?? "").length || void 0) : "";
       const target = alias.targets[0];
-      if (target) base = path27.resolve(root, target.replace("*", wildcard));
+      if (target) base = path28.resolve(root, target.replace("*", wildcard));
     }
   }
   if (!base) return void 0;
   const candidates = [
     base,
     ...[".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].map((extension) => `${base}${extension}`),
-    ...[".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].map((extension) => path27.join(base, `index${extension}`))
+    ...[".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].map((extension) => path28.join(base, `index${extension}`))
   ];
-  const resolved = candidates.find((candidate) => fsSync6.existsSync(candidate) && fsSync6.statSync(candidate).isFile());
-  return resolved ? path27.relative(root, resolved).replace(/\\/g, "/") : void 0;
+  const resolved = candidates.find((candidate) => fsSync7.existsSync(candidate) && fsSync7.statSync(candidate).isFile());
+  return resolved ? path28.relative(root, resolved).replace(/\\/g, "/") : void 0;
 }
 function extractImportSpecifiers(source) {
   const imports = /* @__PURE__ */ new Set();
@@ -17433,27 +17870,27 @@ function extractImportSpecifiers(source) {
   return [...imports];
 }
 async function loadPathAliases(root) {
-  const tsconfigPath = path27.join(root, "tsconfig.json");
+  const tsconfigPath = path28.join(root, "tsconfig.json");
   try {
-    const raw = await fs28.readFile(tsconfigPath, "utf8");
+    const raw = await fs29.readFile(tsconfigPath, "utf8");
     const withoutComments = raw.replace(/^\s*\/\/.*$/gm, "");
     const parsed = JSON.parse(withoutComments);
     const baseUrl = parsed.compilerOptions?.baseUrl ?? ".";
     return Object.entries(parsed.compilerOptions?.paths ?? {}).map(([pattern, targets]) => ({
       pattern,
-      targets: targets.map((target) => path27.join(baseUrl, target))
+      targets: targets.map((target) => path28.join(baseUrl, target))
     }));
   } catch {
     return [];
   }
 }
 async function collectTransitiveDependencies(root, entry, aliases, visited = /* @__PURE__ */ new Set()) {
-  const absoluteEntry = path27.resolve(entry);
+  const absoluteEntry = path28.resolve(entry);
   if (visited.has(absoluteEntry)) return [];
   visited.add(absoluteEntry);
   let source;
   try {
-    source = await fs28.readFile(absoluteEntry, "utf8");
+    source = await fs29.readFile(absoluteEntry, "utf8");
   } catch {
     return [];
   }
@@ -17462,25 +17899,25 @@ async function collectTransitiveDependencies(root, entry, aliases, visited = /*
     const dependency = resolveImport(root, absoluteEntry, specifier, aliases);
     if (!dependency) continue;
     dependencies.push(dependency);
-    const nested = await collectTransitiveDependencies(root, path27.resolve(root, dependency), aliases, visited);
+    const nested = await collectTransitiveDependencies(root, path28.resolve(root, dependency), aliases, visited);
     dependencies.push(...nested);
   }
   return [...new Set(dependencies)];
 }
 async function discoverTestImpactCandidates(root) {
-  const projectRoot = path27.resolve(root);
+  const projectRoot = path28.resolve(root);
   const files = await listTestFiles(projectRoot);
   const aliases = await loadPathAliases(projectRoot);
   const candidates = [];
   for (const file of files) {
     let source;
     try {
-      source = await fs28.readFile(file, "utf8");
+      source = await fs29.readFile(file, "utf8");
     } catch {
       continue;
     }
     const dependencies = await collectTransitiveDependencies(projectRoot, file, aliases);
-    const relativeSource = path27.relative(projectRoot, file).replace(/\\/g, "/");
+    const relativeSource = path28.relative(projectRoot, file).replace(/\\/g, "/");
     const tags = [...new Set([...source.matchAll(/@([A-Za-z][\w-]*)/g)].map((match) => match[1].toLowerCase()))].sort();
     candidates.push({
       testId: relativeSource,
@@ -17493,11 +17930,11 @@ async function discoverTestImpactCandidates(root) {
   return candidates.sort((left, right) => left.testId.localeCompare(right.testId));
 }
 async function analyzeRepositoryImpact(root, changedFiles) {
-  const projectRoot = path27.resolve(root);
+  const projectRoot = path28.resolve(root);
   const candidates = await discoverTestImpactCandidates(projectRoot);
   const normalizedChanged = changedFiles.map((file) => {
-    const absolute = path27.isAbsolute(file) ? file : path27.resolve(projectRoot, file);
-    return path27.relative(projectRoot, absolute).replace(/\\/g, "/");
+    const absolute = path28.isAbsolute(file) ? file : path28.resolve(projectRoot, file);
+    return path28.relative(projectRoot, absolute).replace(/\\/g, "/");
   });
   return {
     root: projectRoot,
@@ -17960,7 +18397,7 @@ function buildTeamDashboard(runs, policy = {}) {
 
 // src/evaluation/repository-runner.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import path28 from "path";
+import path29 from "path";
 var MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
 var SAFE_COMMANDS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "npx"]);
 function executableFor(manager) {
@@ -17995,7 +18432,7 @@ var RepositoryRunner = class {
     return this.runCommand(manifest, executable, args, options);
   }
   static runCommand(manifest, executable, args, options = {}) {
-    const normalizedExecutable = path28.basename(executable).replace(/\.cmd$/i, "").toLowerCase();
+    const normalizedExecutable = path29.basename(executable).replace(/\.cmd$/i, "").toLowerCase();
     if (!SAFE_COMMANDS.has(normalizedExecutable)) {
       return Promise.resolve({
         repository: manifest.name,
@@ -18234,8 +18671,8 @@ function buildEvaluationScorecard(observations) {
 }
 
 // src/framework/config-adapter.ts
-import fs29 from "fs/promises";
-import path29 from "path";
+import fs30 from "fs/promises";
+import path30 from "path";
 import { Project as Project10, SyntaxKind as SyntaxKind6 } from "ts-morph";
 var ConfigAdapter = class _ConfigAdapter {
   static CONFIG_NAMES = [
@@ -18249,9 +18686,9 @@ var ConfigAdapter = class _ConfigAdapter {
    */
   static async findConfig(repoDir) {
     for (const name of _ConfigAdapter.CONFIG_NAMES) {
-      const fullPath = path29.resolve(repoDir, name);
+      const fullPath = path30.resolve(repoDir, name);
       try {
-        await fs29.access(fullPath);
+        await fs30.access(fullPath);
         return _ConfigAdapter.parseConfig(fullPath);
       } catch {
         continue;
@@ -18321,7 +18758,7 @@ var ConfigAdapter = class _ConfigAdapter {
    * Generates a temporary verification config string with retries disabled and tracing enabled.
    */
   static generateVerificationOverride(baseConfigPath) {
-    const importStatement = baseConfigPath ? `import baseConfig from './${path29.basename(baseConfigPath).replace(/\.ts$/, "")}';
+    const importStatement = baseConfigPath ? `import baseConfig from './${path30.basename(baseConfigPath).replace(/\.ts$/, "")}';
 ` : `import { defineConfig } from '@playwright/test';
 `;
     return `${importStatement}
@@ -18343,13 +18780,13 @@ export default {
 
 // src/mcp/server.ts
 import readline from "readline";
-import path30 from "path";
-import fs30 from "fs";
+import path31 from "path";
+import fs31 from "fs";
 var McpServer = class {
   rl;
   workspaceRoot;
   constructor(workspaceRoot = process.cwd()) {
-    this.workspaceRoot = path30.resolve(workspaceRoot);
+    this.workspaceRoot = path31.resolve(workspaceRoot);
     this.rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -18369,26 +18806,26 @@ var McpServer = class {
       );
     }
     const normalizedTarget = process.platform === "win32" ? targetPath : targetPath.replace(/\\/g, "/");
-    const resolved = path30.resolve(this.workspaceRoot, normalizedTarget);
-    if (!fs30.existsSync(this.workspaceRoot)) {
+    const resolved = path31.resolve(this.workspaceRoot, normalizedTarget);
+    if (!fs31.existsSync(this.workspaceRoot)) {
       throw new Error(`Workspace root does not exist: '${this.workspaceRoot}'`);
     }
-    const canonicalWorkspace = fs30.realpathSync(this.workspaceRoot);
+    const canonicalWorkspace = fs31.realpathSync(this.workspaceRoot);
     let canonicalTarget;
-    if (fs30.existsSync(resolved)) {
-      canonicalTarget = fs30.realpathSync(resolved);
+    if (fs31.existsSync(resolved)) {
+      canonicalTarget = fs31.realpathSync(resolved);
     } else {
-      const parent = path30.dirname(resolved);
-      if (fs30.existsSync(parent)) {
-        canonicalTarget = path30.join(fs30.realpathSync(parent), path30.basename(resolved));
+      const parent = path31.dirname(resolved);
+      if (fs31.existsSync(parent)) {
+        canonicalTarget = path31.join(fs31.realpathSync(parent), path31.basename(resolved));
       } else {
         throw new Error(
           `Workspace Security Violation: Path '${targetPath}' cannot be resolved inside authorized workspace boundary '${canonicalWorkspace}'.`
         );
       }
     }
-    const rel = path30.relative(canonicalWorkspace, canonicalTarget);
-    if (rel.startsWith("..") || path30.isAbsolute(rel)) {
+    const rel = path31.relative(canonicalWorkspace, canonicalTarget);
+    if (rel.startsWith("..") || path31.isAbsolute(rel)) {
       throw new Error(
         `Workspace Security Violation: Path '${targetPath}' resolves to '${canonicalTarget}' outside authorized workspace boundary '${canonicalWorkspace}'.`
       );
@@ -18675,7 +19112,7 @@ var McpServer = class {
           };
         }
         const tracePath = this.assertPathInWorkspace(tracePathRaw);
-        if (!fs30.existsSync(tracePath)) {
+        if (!fs31.existsSync(tracePath)) {
           throw new Error(`Trace file not found: '${tracePath}'`);
         }
         const { traceEntryName, networkEntryName, traceEntryNames, networkEntryNames } = ArchiveReader.findTraceFileEntries(tracePath);
@@ -18697,7 +19134,7 @@ var McpServer = class {
         let context = await adapter.parse(manifest, traceLines, networkLines);
         if (args?.errorContextPath) {
           const errorContextPath = this.assertPathInWorkspace(args.errorContextPath);
-          const errorContext = await fs30.promises.readFile(errorContextPath, "utf8");
+          const errorContext = await fs31.promises.readFile(errorContextPath, "utf8");
           context = supplementDiagnosticContext(context, parseExternalFailureEvidence(errorContext));
         }
         const correlated = EvidenceCorrelator.correlate(context);
@@ -18918,14 +19355,14 @@ var McpServer = class {
         }
         const pomPath = this.assertPathInWorkspace(pomRaw);
         const testPath = this.assertPathInWorkspace(testRaw);
-        if (!fs30.existsSync(pomPath)) throw new Error(`Page Object file not found: '${pomPath}'`);
-        if (!fs30.existsSync(testPath)) throw new Error(`Test spec file not found: '${testPath}'`);
+        if (!fs31.existsSync(pomPath)) throw new Error(`Page Object file not found: '${pomPath}'`);
+        if (!fs31.existsSync(testPath)) throw new Error(`Test spec file not found: '${testPath}'`);
         const grammar = DiffAllowlistValidator.validateLocatorGrammar(replacementSelector);
         if (!grammar.isValid) {
           throw new Error(`Security Violation: Disallowed replacement expression '${replacementSelector}'. ${grammar.reason}`);
         }
-        const origPomSource = await fs30.promises.readFile(pomPath, "utf-8");
-        const origTestSource = await fs30.promises.readFile(testPath, "utf-8");
+        const origPomSource = await fs31.promises.readFile(pomPath, "utf-8");
+        const origTestSource = await fs31.promises.readFile(testPath, "utf-8");
         const initialFingerprint = AssertionHasher.computeFingerprint(testPath);
         const patcher = new AstPatcher();
         const inMemPatch = patcher.patchPageObjectInMemory(origPomSource, {
@@ -18976,7 +19413,7 @@ var McpServer = class {
           const postFingerprint = AssertionHasher.computeFingerprint(testPath);
           const assertionIntact = initialFingerprint === postFingerprint;
           if (!assertionIntact) {
-            await fs30.promises.writeFile(pomPath, origPomSource, "utf8");
+            await fs31.promises.writeFile(pomPath, origPomSource, "utf8");
             return {
               jsonrpc: "2.0",
               id,
@@ -19102,7 +19539,7 @@ ${generated.specCode}`
           verify,
           runMutations
         } = args ?? {};
-        const targetWorkspace = typeof workspaceRoot === "string" && workspaceRoot.trim() ? path30.resolve(workspaceRoot) : this.workspaceRoot;
+        const targetWorkspace = typeof workspaceRoot === "string" && workspaceRoot.trim() ? path31.resolve(workspaceRoot) : this.workspaceRoot;
         const resolvedAuthor = author === "template" || author === "hybrid" || author === "llm" ? author : void 0;
         const result = await runEvidenceDrivenGeneration({
           workspaceRoot: targetWorkspace,
@@ -19187,41 +19624,41 @@ ${generated.specCode}`
 };
 
 // src/cli/index.ts
-import * as path31 from "path";
-import * as fs31 from "fs";
+import * as path32 from "path";
+import * as fs32 from "fs";
 import { spawn as spawn3, execSync } from "child_process";
 function findTraceArchives(targetPath) {
   if (targetPath && !targetPath.startsWith("--")) {
-    const resolved = path31.resolve(targetPath);
-    if (fs31.existsSync(resolved)) {
-      if (fs31.statSync(resolved).isFile() && resolved.endsWith(".zip")) {
+    const resolved = path32.resolve(targetPath);
+    if (fs32.existsSync(resolved)) {
+      if (fs32.statSync(resolved).isFile() && resolved.endsWith(".zip")) {
         return [resolved];
       }
     }
   }
   const candidateDirs = [
-    targetPath && !targetPath.startsWith("--") && fs31.existsSync(targetPath) && fs31.statSync(targetPath).isDirectory() ? path31.resolve(targetPath) : null,
-    path31.resolve("test-results"),
-    path31.resolve("playwright-report"),
+    targetPath && !targetPath.startsWith("--") && fs32.existsSync(targetPath) && fs32.statSync(targetPath).isDirectory() ? path32.resolve(targetPath) : null,
+    path32.resolve("test-results"),
+    path32.resolve("playwright-report"),
     process.cwd()
   ].filter(Boolean);
   const found = [];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of candidateDirs) {
-    if (!fs31.existsSync(dir)) continue;
+    if (!fs32.existsSync(dir)) continue;
     try {
-      const entries = fs31.readdirSync(dir, { recursive: true });
+      const entries = fs32.readdirSync(dir, { recursive: true });
       for (const entry of entries) {
-        const fullPath = path31.join(dir, String(entry));
+        const fullPath = path32.join(dir, String(entry));
         if (fullPath.endsWith(".zip") && !seen.has(fullPath)) {
           try {
-            const stat = fs31.statSync(fullPath);
+            const stat = fs32.statSync(fullPath);
             if (stat.isFile()) {
               seen.add(fullPath);
               let hasFailure = false;
               try {
                 const discovery = ArchiveReader.findTraceFileEntries(fullPath);
-                hasFailure = Boolean(discovery.hasFailure || discovery.failureScore && discovery.failureScore > 0);
+                hasFailure = Boolean(discovery.hasFailure);
               } catch {
               }
               const isTestResults = fullPath.includes("test-results");
@@ -19267,8 +19704,8 @@ async function runCli(argv) {
       const outputPath = outputPathIndex >= 0 ? argv[outputPathIndex + 1] : void 0;
       const serialized = JSON.stringify({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), testbedPath, repositories: manifests }, null, 2);
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), serialized, "utf8");
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), serialized, "utf8");
       }
       if (argv.includes("--json") || outputPath) {
         console.log(serialized);
@@ -19313,8 +19750,8 @@ async function runCli(argv) {
       }
       const serialized = JSON.stringify({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), testbedPath, results }, null, 2);
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), serialized, "utf8");
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), serialized, "utf8");
       }
       console.log(serialized);
       return;
@@ -19334,9 +19771,9 @@ async function runCli(argv) {
     }
     const tracePath = traces[0];
     if (traces.length > 1) {
-      console.log(`[pw-intel] Auto-discovered ${traces.length} trace files. Diagnosing most recent: ${path31.relative(process.cwd(), tracePath)}`);
-    } else if (!candidateArg || candidateArg.startsWith("--") || fs31.existsSync(candidateArg) && fs31.statSync(candidateArg).isDirectory()) {
-      console.log(`[pw-intel] Auto-discovered trace: ${path31.relative(process.cwd(), tracePath)}`);
+      console.log(`[pw-intel] Auto-discovered ${traces.length} trace files. Diagnosing most recent: ${path32.relative(process.cwd(), tracePath)}`);
+    } else if (!candidateArg || candidateArg.startsWith("--") || fs32.existsSync(candidateArg) && fs32.statSync(candidateArg).isDirectory()) {
+      console.log(`[pw-intel] Auto-discovered trace: ${path32.relative(process.cwd(), tracePath)}`);
     }
     try {
       const { traceEntryName, networkEntryName, traceEntryNames, networkEntryNames } = ArchiveReader.findTraceFileEntries(tracePath);
@@ -19351,7 +19788,7 @@ async function runCli(argv) {
       const errorContextIndex = argv.indexOf("--error-context");
       const errorContextPath = errorContextIndex >= 0 ? argv[errorContextIndex + 1] : void 0;
       if (errorContextPath) {
-        const errorContext = await fs31.promises.readFile(path31.resolve(errorContextPath), "utf8");
+        const errorContext = await fs32.promises.readFile(path32.resolve(errorContextPath), "utf8");
         context = supplementDiagnosticContext(context, parseExternalFailureEvidence(errorContext));
       }
       const correlated = EvidenceCorrelator.correlate(context);
@@ -19437,6 +19874,80 @@ async function runCli(argv) {
     return;
   }
   if (command === "autonomous-repair") {
+    const option = (name) => {
+      const index = argv.indexOf(name);
+      return index >= 0 ? argv[index + 1] : void 0;
+    };
+    if (argv.includes("--all")) {
+      try {
+        const batchResult = await runBatchRepairWorkflow({
+          workspaceRoot: option("--workspace") ?? process.cwd(),
+          execute: argv.includes("--execute"),
+          autoPromote: argv.includes("--promote"),
+          configPath: option("--config"),
+          worktreeId: option("--worktree-id"),
+          enableBrowserInvestigation: argv.includes("--browser"),
+          browserUrl: option("--browser-url"),
+          browserAllowedHosts: (option("--allow-host") ?? "").split(",").map((h) => h.trim()).filter(Boolean),
+          enableTestExecution: argv.includes("--run-tests")
+        });
+        const reportsDir = path32.resolve(process.cwd(), ".pie", "reports");
+        await fs32.promises.mkdir(reportsDir, { recursive: true });
+        const reportJsonPath = path32.resolve(reportsDir, "batch-repair-report.json");
+        await fs32.promises.writeFile(reportJsonPath, `${JSON.stringify(batchResult, null, 2)}
+`, "utf8");
+        if (argv.includes("--json")) {
+          console.log(JSON.stringify(batchResult, null, 2));
+        } else {
+          const divider = "\u2500".repeat(72);
+          console.log("");
+          console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+          console.log("\u2551        PLAYWRIGHT INTELLIGENCE ENGINE: BATCH AUTO-HEALING            \u2551");
+          console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+          console.log("");
+          console.log(`Discovered Traces  : ${batchResult.totalTraces}`);
+          console.log(`Repaired & Verified: ${batchResult.repairedCount}`);
+          console.log(`Abstained          : ${batchResult.abstainedCount}`);
+          console.log(`Failed             : ${batchResult.failedCount}`);
+          console.log(`Batch Status       : ${batchResult.status}`);
+          console.log(divider);
+          console.log("Failure Clusters:");
+          if (batchResult.clusters.length > 0) {
+            for (const c of batchResult.clusters) {
+              console.log(`  \u2022 [${c.severity.toUpperCase()}] ${c.fingerprint.category} (count: ${c.count})`);
+            }
+          } else {
+            console.log("  \u2022 None");
+          }
+          console.log(divider);
+          console.log("Test Repair Summary:");
+          for (const item of batchResult.items) {
+            const icon = item.status === "PROMOTED" || item.status === "VERIFIED" ? "\u2705" : item.status === "ABSTAINED" ? "\u26A0\uFE0F" : item.status === "PROPOSAL_READY" ? "\u{1F4A1}" : "\u274C";
+            const spec = item.testTitle ?? path32.basename(item.tracePath);
+            console.log(`  ${icon} [${item.status}] ${spec}`);
+            if (item.failedTarget) console.log(`     Failed Target : ${item.failedTarget}`);
+            if (item.healedLocator) console.log(`     Healed Locator: ${item.healedLocator}`);
+            if (item.targetFilePath) console.log(`     Target File   : ${path32.relative(process.cwd(), item.targetFilePath)}`);
+            if (item.reason && item.status === "ABSTAINED") console.log(`     Abstain Reason: ${item.reason}`);
+          }
+          console.log(divider);
+          if (batchResult.promotedFiles && batchResult.promotedFiles.length > 0) {
+            console.log("Promoted Files:");
+            for (const file of batchResult.promotedFiles) {
+              console.log(`  \u{1F389} ${file}`);
+            }
+            console.log(divider);
+          }
+          console.log(`Report JSON        : ${path32.relative(process.cwd(), reportJsonPath)}`);
+          console.log("(Pass --json to view full machine-readable payload)");
+        }
+        if (batchResult.status === "FAILED") process.exitCode = 1;
+        return;
+      } catch (err) {
+        console.error(`Batch repair failed: ${err?.message ?? String(err)}`);
+        process.exit(1);
+      }
+    }
     const candidateArg = argv[3];
     const traces = findTraceArchives(candidateArg);
     if (traces.length === 0) {
@@ -19447,15 +19958,11 @@ async function runCli(argv) {
     }
     const tracePath = traces[0];
     if (traces.length > 1) {
-      console.log(`[pw-intel] Auto-discovered ${traces.length} trace files. Repairing most recent: ${path31.relative(process.cwd(), tracePath)}`);
-    } else if (!candidateArg || candidateArg.startsWith("--") || fs31.existsSync(candidateArg) && fs31.statSync(candidateArg).isDirectory()) {
-      console.log(`[pw-intel] Auto-discovered trace: ${path31.relative(process.cwd(), tracePath)}`);
+      console.log(`[pw-intel] Auto-discovered ${traces.length} trace files. Repairing most recent: ${path32.relative(process.cwd(), tracePath)}`);
+    } else if (!candidateArg || candidateArg.startsWith("--") || fs32.existsSync(candidateArg) && fs32.statSync(candidateArg).isDirectory()) {
+      console.log(`[pw-intel] Auto-discovered trace: ${path32.relative(process.cwd(), tracePath)}`);
     }
     try {
-      const option = (name) => {
-        const index = argv.indexOf(name);
-        return index >= 0 ? argv[index + 1] : void 0;
-      };
       const result = await runAutonomousRepairWorkflow({
         tracePath,
         workspaceRoot: option("--workspace") ?? process.cwd(),
@@ -19496,14 +20003,15 @@ async function runCli(argv) {
         console.log("\u2551        PLAYWRIGHT INTELLIGENCE ENGINE: AUTONOMOUS REPAIR             \u2551");
         console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
         console.log("");
-        console.log(`Target Trace      : ${path31.relative(process.cwd(), tracePath)}`);
+        console.log(`Target Trace      : ${path32.relative(process.cwd(), tracePath)}`);
         console.log(`Repair Status     : ${result.status}`);
         if (result.reason) {
           console.log(`Status Reason     : ${result.reason}`);
         }
         console.log(divider);
         console.log("Agent Diagnostic & Proposal:");
-        console.log(`  \u2022 Classification: ${result.proposalRun.agent.classification ?? "N/A"}`);
+        const classificationStr = typeof result.proposalRun.agent.classification === "object" && result.proposalRun.agent.classification !== null ? result.proposalRun.agent.classification.category ?? result.proposalRun.agent.classification.name ?? "N/A" : result.proposalRun.agent.classification ?? "N/A";
+        console.log(`  \u2022 Classification: ${classificationStr}`);
         console.log(`  \u2022 Model Invoked : ${result.proposalRun.agent.modelInvoked}`);
         console.log(`  \u2022 Steps / Turns : ${result.proposalRun.agent.steps?.length ?? 0}`);
         if (result.proposal) {
@@ -19583,21 +20091,21 @@ async function runCli(argv) {
     return;
   }
   if (command === "benchmark") {
-    const cliDir = path31.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
-    const packageRootDir = path31.resolve(cliDir, "..");
-    const packageBenchmarkScript = path31.resolve(packageRootDir, "benchmarks", "runner", "master-benchmark-runner.ts");
-    const localBenchmarkScript = path31.resolve(process.cwd(), "benchmarks", "runner", "master-benchmark-runner.ts");
-    const benchmarkScript = fs31.existsSync(packageBenchmarkScript) ? packageBenchmarkScript : fs31.existsSync(localBenchmarkScript) ? localBenchmarkScript : void 0;
+    const cliDir = path32.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+    const packageRootDir = path32.resolve(cliDir, "..");
+    const packageBenchmarkScript = path32.resolve(packageRootDir, "benchmarks", "runner", "master-benchmark-runner.ts");
+    const localBenchmarkScript = path32.resolve(process.cwd(), "benchmarks", "runner", "master-benchmark-runner.ts");
+    const benchmarkScript = fs32.existsSync(packageBenchmarkScript) ? packageBenchmarkScript : fs32.existsSync(localBenchmarkScript) ? localBenchmarkScript : void 0;
     if (!benchmarkScript) {
       console.log("Empirical benchmark harness is maintained in the research testbed repository.");
       console.log("See docs/BENCHMARK.md for methodology, metrics, and empirical validation results.");
       return;
     }
     const tsxCandidatePaths = [
-      path31.resolve(packageRootDir, "node_modules", "tsx", "dist", "cli.mjs"),
-      path31.resolve(process.cwd(), "node_modules", "tsx", "dist", "cli.mjs")
+      path32.resolve(packageRootDir, "node_modules", "tsx", "dist", "cli.mjs"),
+      path32.resolve(process.cwd(), "node_modules", "tsx", "dist", "cli.mjs")
     ];
-    const tsxCli = tsxCandidatePaths.find((p) => fs31.existsSync(p));
+    const tsxCli = tsxCandidatePaths.find((p) => fs32.existsSync(p));
     let executable;
     let finalArgs;
     if (tsxCli) {
@@ -19632,7 +20140,7 @@ async function runCli(argv) {
       const endpointArg = option("--endpoint");
       const result = await initProjectConfig(workspaceRoot, { force: argv.includes("--force") });
       if (apiKeyArg) {
-        const envPath = path31.join(workspaceRoot, ".env");
+        const envPath = path32.join(workspaceRoot, ".env");
         const envLines = [
           "# Playwright Intelligence Engine (PIE) Configuration",
           `PIE_LLM_API_KEY=${apiKeyArg}`,
@@ -19643,13 +20151,13 @@ async function runCli(argv) {
         } else if (apiKeyArg.startsWith("sk-proj-") || apiKeyArg.startsWith("sk-")) {
           envLines.push("PIE_LLM_ENDPOINT=https://api.openai.com/v1/chat/completions");
         }
-        await fs31.promises.writeFile(envPath, `${envLines.join("\n")}
+        await fs32.promises.writeFile(envPath, `${envLines.join("\n")}
 `, "utf8");
-        const gitignorePath = path31.join(workspaceRoot, ".gitignore");
+        const gitignorePath = path32.join(workspaceRoot, ".gitignore");
         try {
-          const gitignoreContent = await fs31.promises.readFile(gitignorePath, "utf8").catch(() => "");
+          const gitignoreContent = await fs32.promises.readFile(gitignorePath, "utf8").catch(() => "");
           if (!gitignoreContent.includes(".env")) {
-            await fs31.promises.appendFile(gitignorePath, "\n.env\n", "utf8");
+            await fs32.promises.appendFile(gitignorePath, "\n.env\n", "utf8");
           }
         } catch {
         }
@@ -19684,8 +20192,8 @@ async function runCli(argv) {
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(profile, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(profile, null, 2)}
 `, "utf8");
       } else {
         await writeRepositoryProfile(workspaceRoot, profile);
@@ -19712,7 +20220,7 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const parsed = JSON.parse(await fs31.promises.readFile(path31.resolve(inputPath), "utf8"));
+      const parsed = JSON.parse(await fs32.promises.readFile(path32.resolve(inputPath), "utf8"));
       const observations = Array.isArray(parsed) ? parsed : parsed.observations ?? [];
       const clusters = clusterFailures(observations);
       const report = {
@@ -19724,8 +20232,8 @@ async function runCli(argv) {
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(report, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(report, null, 2)}
 `, "utf8");
       }
       console.log(JSON.stringify(report, null, 2));
@@ -19742,15 +20250,15 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const parsed = JSON.parse(await fs31.promises.readFile(path31.resolve(inputPath), "utf8"));
+      const parsed = JSON.parse(await fs32.promises.readFile(path32.resolve(inputPath), "utf8"));
       const observations = Array.isArray(parsed) ? parsed : parsed.observations ?? parsed.diagnosisResults ?? [];
       const scorecard = buildEvaluationScorecard(observations);
-      const report = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), inputPath: path31.resolve(inputPath), ...scorecard };
+      const report = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), inputPath: path32.resolve(inputPath), ...scorecard };
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(report, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(report, null, 2)}
 `, "utf8");
       }
       console.log(JSON.stringify(report, null, 2));
@@ -19767,23 +20275,23 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const requirementsRaw = JSON.parse(await fs31.promises.readFile(path31.resolve(requirementsPath), "utf8"));
+      const requirementsRaw = JSON.parse(await fs32.promises.readFile(path32.resolve(requirementsPath), "utf8"));
       const requirements = Array.isArray(requirementsRaw) ? requirementsRaw : Array.isArray(requirementsRaw.requirements) ? requirementsRaw.requirements : typeof requirementsRaw.requirements === "string" ? [{ id: "requirement-1", title: requirementsRaw.title ?? requirementsRaw.requirements.slice(0, 100), description: requirementsRaw.requirements }] : [];
       if (requirements.length === 0) throw new Error("The requirements document contains no requirements");
       const testsIndex = argv.indexOf("--tests");
       const testsPath = testsIndex >= 0 ? argv[testsIndex + 1] : void 0;
       let existingTests = [];
       if (testsPath) {
-        const testsRaw = JSON.parse(await fs31.promises.readFile(path31.resolve(testsPath), "utf8"));
+        const testsRaw = JSON.parse(await fs32.promises.readFile(path32.resolve(testsPath), "utf8"));
         existingTests = Array.isArray(testsRaw) ? testsRaw : testsRaw.tests ?? [];
       }
       const plan = buildTestIntelligencePlan(requirements, existingTests);
-      const report = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), requirementsPath: path31.resolve(requirementsPath), testsPath: testsPath ? path31.resolve(testsPath) : void 0, ...plan };
+      const report = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), requirementsPath: path32.resolve(requirementsPath), testsPath: testsPath ? path32.resolve(testsPath) : void 0, ...plan };
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(report, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(report, null, 2)}
 `, "utf8");
       }
       console.log(JSON.stringify(report, null, 2));
@@ -19800,7 +20308,7 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const requirementsRaw = JSON.parse(await fs31.promises.readFile(path31.resolve(requirementsPath), "utf8"));
+      const requirementsRaw = JSON.parse(await fs32.promises.readFile(path32.resolve(requirementsPath), "utf8"));
       const requirementsDocument = Array.isArray(requirementsRaw) ? void 0 : requirementsRaw;
       const requirements = Array.isArray(requirementsRaw) ? requirementsRaw : Array.isArray(requirementsRaw.requirements) ? requirementsRaw.requirements : typeof requirementsRaw.requirements === "string" ? [{ id: "requirement-1", title: requirementsRaw.title ?? requirementsRaw.requirements.slice(0, 100), description: requirementsRaw.requirements }] : [];
       if (requirements.length === 0) throw new Error("The requirements document contains no requirements");
@@ -19808,7 +20316,7 @@ async function runCli(argv) {
       const testsPath = testsIndex >= 0 ? argv[testsIndex + 1] : void 0;
       let existingTests = [];
       if (testsPath) {
-        const testsRaw = JSON.parse(await fs31.promises.readFile(path31.resolve(testsPath), "utf8"));
+        const testsRaw = JSON.parse(await fs32.promises.readFile(path32.resolve(testsPath), "utf8"));
         existingTests = Array.isArray(testsRaw) ? testsRaw : testsRaw.tests ?? [];
       }
       const modeIndex = argv.indexOf("--mode");
@@ -19831,7 +20339,41 @@ async function runCli(argv) {
         write: argv.includes("--write"),
         verify: argv.includes("--verify")
       });
-      console.log(JSON.stringify({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), requirementsPath: path31.resolve(requirementsPath), ...result }, null, 2));
+      const reportPayload = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), requirementsPath: path32.resolve(requirementsPath), ...result };
+      const reportsDir = path32.resolve(process.cwd(), ".pie", "reports");
+      await fs32.promises.mkdir(reportsDir, { recursive: true });
+      const reportJsonPath = path32.resolve(reportsDir, "generation-report.json");
+      await fs32.promises.writeFile(reportJsonPath, `${JSON.stringify(reportPayload, null, 2)}
+`, "utf8");
+      if (argv.includes("--json")) {
+        console.log(JSON.stringify(reportPayload, null, 2));
+      } else {
+        const divider = "\u2500".repeat(72);
+        console.log("");
+        console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+        console.log("\u2551        PLAYWRIGHT INTELLIGENCE ENGINE: GENERATION AGENT              \u2551");
+        console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+        console.log("");
+        console.log(`Requirements File : ${path32.relative(process.cwd(), requirementsPath)}`);
+        console.log(`Mode              : ${mode} (${author})`);
+        console.log(`Generation Status : ${result.status}`);
+        if (result.reason) {
+          console.log(`Status Reason     : ${result.reason}`);
+        }
+        console.log(divider);
+        const generatedList = result.generatedFiles ?? [];
+        console.log(`Generated Files (${generatedList.length}):`);
+        if (generatedList.length > 0) {
+          for (const file of generatedList) {
+            console.log(`  \u2022 ${file}`);
+          }
+        } else {
+          console.log("  \u2022 None (No files written)");
+        }
+        console.log(divider);
+        console.log(`Report JSON       : ${path32.relative(process.cwd(), reportJsonPath)}`);
+        console.log("(Pass --json to view full machine-readable payload)");
+      }
       if (result.status === "ABSTAINED" || result.status === "MODEL_NOT_CONFIGURED" || result.status === "NEEDS_INPUT" || result.status === "VERIFICATION_FAILED" || result.status === "AGENT_NO_PROGRESS") process.exitCode = 1;
     } catch (err) {
       console.error(`Generation agent failed: ${err?.message ?? String(err)}`);
@@ -19863,15 +20405,15 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const parsed = JSON.parse(await fs31.promises.readFile(path31.resolve(inputPath), "utf8"));
+      const parsed = JSON.parse(await fs32.promises.readFile(path32.resolve(inputPath), "utf8"));
       const runs = Array.isArray(parsed) ? parsed : parsed.runs ?? [];
       const summaries = analyzeTestStability(runs);
       const report = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), runCount: runs.length, testCount: summaries.length, flakyTestCount: summaries.filter((summary) => summary.flaky).length, tests: summaries };
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(report, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(report, null, 2)}
 `, "utf8");
       }
       console.log(JSON.stringify(report, null, 2));
@@ -19888,14 +20430,14 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const parsed = JSON.parse(await fs31.promises.readFile(path31.resolve(inputPath), "utf8"));
+      const parsed = JSON.parse(await fs32.promises.readFile(path32.resolve(inputPath), "utf8"));
       const runs = Array.isArray(parsed) ? parsed : parsed.runs ?? [];
       const report = buildTeamDashboard(runs);
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(report, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(report, null, 2)}
 `, "utf8");
       }
       console.log(JSON.stringify(report, null, 2));
@@ -19912,7 +20454,7 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const parsed = JSON.parse(await fs31.promises.readFile(path31.resolve(changedPath), "utf8"));
+      const parsed = JSON.parse(await fs32.promises.readFile(path32.resolve(changedPath), "utf8"));
       const changedFiles = Array.isArray(parsed) ? parsed : parsed.changedFiles ?? [];
       const rootIndex = argv.indexOf("--root");
       const root = (rootIndex >= 0 ? argv[rootIndex + 1] : void 0) ?? process.cwd();
@@ -19920,8 +20462,8 @@ async function runCli(argv) {
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(report, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(report, null, 2)}
 `, "utf8");
       }
       console.log(JSON.stringify(report, null, 2));
@@ -19943,15 +20485,15 @@ async function runCli(argv) {
       if (mode !== "greenfield" && mode !== "brownfield") throw new Error("--mode must be 'greenfield' or 'brownfield'");
       const requirementsIndex = argv.indexOf("--requirements");
       const requirementsPath = requirementsIndex >= 0 ? argv[requirementsIndex + 1] : void 0;
-      const requirements = requirementsPath ? JSON.parse(await fs31.promises.readFile(path31.resolve(requirementsPath), "utf8")) : {};
+      const requirements = requirementsPath ? JSON.parse(await fs32.promises.readFile(path32.resolve(requirementsPath), "utf8")) : {};
       const baseUrlIndex = argv.indexOf("--baseUrl");
       const baseUrlFromArg = baseUrlIndex >= 0 ? argv[baseUrlIndex + 1] : void 0;
       const baseUrl = baseUrlFromArg ?? requirements.baseUrl;
       let appModel = requirements.appModel;
       const appModelIndex = argv.indexOf("--app-model");
       if (appModelIndex >= 0 && argv[appModelIndex + 1]) {
-        const modelPath = path31.resolve(argv[appModelIndex + 1]);
-        appModel = JSON.parse(await fs31.promises.readFile(modelPath, "utf8"));
+        const modelPath = path32.resolve(argv[appModelIndex + 1]);
+        appModel = JSON.parse(await fs32.promises.readFile(modelPath, "utf8"));
       } else if (baseUrl && (argv.includes("--crawl") || (!requirements.steps || requirements.steps.length === 0))) {
         try {
           appModel = await AppCrawler.crawl({ baseUrl });
@@ -19982,20 +20524,20 @@ async function runCli(argv) {
           });
           if (verification.exitCode === 0) {
             try {
-              const specFullPath = path31.resolve(process.cwd(), spec.relativePath);
-              const originalContent = await fs31.promises.readFile(specFullPath, "utf8");
+              const specFullPath = path32.resolve(process.cwd(), spec.relativePath);
+              const originalContent = await fs32.promises.readFile(specFullPath, "utf8");
               const mutatedContent = originalContent.replace(
                 /expect\(page\.getByText\(['"][^'"]+['"]\)\)/,
                 `expect(page.getByText('__UNMATCHED_FALSIFICATION_TARGET__'))`
               );
               if (mutatedContent !== originalContent) {
-                await fs31.promises.writeFile(specFullPath, mutatedContent, "utf8");
+                await fs32.promises.writeFile(specFullPath, mutatedContent, "utf8");
                 const mutatedRun = await ExecutionRunner.run("npx", {
                   cwd: process.cwd(),
                   args: ["playwright", "test", spec.relativePath, "--reporter=line"],
                   timeoutMs: 6e4
                 });
-                await fs31.promises.writeFile(specFullPath, originalContent, "utf8");
+                await fs32.promises.writeFile(specFullPath, originalContent, "utf8");
                 verification.falsifiable = mutatedRun.exitCode !== 0;
               }
             } catch {
@@ -20008,8 +20550,8 @@ async function runCli(argv) {
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(report, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(report, null, 2)}
 `, "utf8");
       }
       console.log(JSON.stringify(report, null, 2));
@@ -20025,7 +20567,7 @@ async function runCli(argv) {
       const idx = argv.indexOf(flag);
       return idx >= 0 && argv[idx + 1] && !argv[idx + 1].startsWith("--") ? argv[idx + 1] : void 0;
     };
-    const workspaceRoot = path31.resolve(readFlag("--workspace") ?? process.cwd());
+    const workspaceRoot = path32.resolve(readFlag("--workspace") ?? process.cwd());
     const baseUrl = readFlag("--url") ?? readFlag("--base-url");
     const requirementsPath = readFlag("--requirements");
     const markdownPath = readFlag("--markdown");
@@ -20041,13 +20583,13 @@ async function runCli(argv) {
     const runMutations = !argv.includes("--no-mutate");
     const allowMutatingActions = argv.includes("--allow-mutating");
     try {
-      let markdown = markdownPath ? await fs31.promises.readFile(path31.resolve(markdownPath), "utf8") : void 0;
+      let markdown = markdownPath ? await fs32.promises.readFile(path32.resolve(markdownPath), "utf8") : void 0;
       let jsonRequirements;
       let prompt = promptFlag;
-      let featureText = gherkinPath ? await fs31.promises.readFile(path31.resolve(gherkinPath), "utf8") : void 0;
+      let featureText = gherkinPath ? await fs32.promises.readFile(path32.resolve(gherkinPath), "utf8") : void 0;
       if (requirementsPath) {
-        const resolvedReqPath = path31.resolve(requirementsPath);
-        const rawReq = await fs31.promises.readFile(resolvedReqPath, "utf8");
+        const resolvedReqPath = path32.resolve(requirementsPath);
+        const rawReq = await fs32.promises.readFile(resolvedReqPath, "utf8");
         if (resolvedReqPath.toLowerCase().endsWith(".json")) {
           jsonRequirements = JSON.parse(rawReq);
         } else if (resolvedReqPath.toLowerCase().endsWith(".feature")) {
@@ -20090,13 +20632,57 @@ async function runCli(argv) {
         verify,
         runMutations
       });
+      const reportsDir = path32.resolve(process.cwd(), ".pie", "reports");
+      await fs32.promises.mkdir(reportsDir, { recursive: true });
+      const defaultReportPath = path32.resolve(reportsDir, "qa-report.json");
       const outFlag = readFlag("--out");
-      if (outFlag) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outFlag)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outFlag), `${JSON.stringify(result.qaReport, null, 2)}
+      const targetReportJsonPath = outFlag ? path32.resolve(outFlag) : defaultReportPath;
+      await fs32.promises.mkdir(path32.dirname(targetReportJsonPath), { recursive: true });
+      await fs32.promises.writeFile(targetReportJsonPath, `${JSON.stringify(result.qaReport, null, 2)}
 `, "utf8");
+      if (argv.includes("--json")) {
+        console.log(JSON.stringify(result.qaReport, null, 2));
+      } else {
+        const divider = "\u2500".repeat(72);
+        console.log("");
+        console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+        console.log("\u2551               PLAYWRIGHT INTELLIGENCE ENGINE: QA REPORT              \u2551");
+        console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+        console.log("");
+        console.log(`Feature           : ${result.qaReport.featureName}`);
+        console.log(`Topology          : ${result.qaReport.topology}`);
+        console.log(`Status            : ${result.qaReport.status}`);
+        console.log(`Runtime Verified  : ${result.qaReport.runtimeVerified ? "\u2705 YES" : "\u274C NO"}`);
+        console.log(`Static Validation : ${result.qaReport.staticValidation.passed ? "\u2705 PASSED" : "\u274C FAILED"}`);
+        console.log(divider);
+        console.log("Findings & Diagnostics:");
+        if (result.qaReport.findings && result.qaReport.findings.length > 0) {
+          for (const finding of result.qaReport.findings) {
+            const sev = finding.severity ? finding.severity.toUpperCase() : "INFO";
+            console.log(`  \u2022 [${sev}] ${finding.actualBehavior}`);
+          }
+        } else {
+          console.log("  \u2022 No defects or runtime errors discovered.");
+        }
+        if (result.qaReport.staticValidation.violations.length > 0) {
+          console.log("\nValidation Violations:");
+          for (const viol of result.qaReport.staticValidation.violations) {
+            console.log(`  \u2022 ${viol}`);
+          }
+        }
+        console.log(divider);
+        console.log("Artifacts Generated:");
+        console.log(`  \u2022 Generated Files : ${result.qaReport.generatedFiles.length > 0 ? result.qaReport.generatedFiles.join(", ") : "None"}`);
+        if (result.qaReport.artifacts?.featureFilePath) {
+          console.log(`  \u2022 Feature File    : ${path32.relative(process.cwd(), result.qaReport.artifacts.featureFilePath)}`);
+        }
+        if (result.qaReport.artifacts?.explorationBundlePath) {
+          console.log(`  \u2022 Exploration Log : ${path32.relative(process.cwd(), result.qaReport.artifacts.explorationBundlePath)}`);
+        }
+        console.log(`  \u2022 Report JSON     : ${path32.relative(process.cwd(), targetReportJsonPath)}`);
+        console.log(divider);
+        console.log("(Pass --json to view full machine-readable report)");
       }
-      console.log(JSON.stringify(result.qaReport, null, 2));
     } catch (err) {
       console.error(`QA pipeline failed: ${err?.message ?? String(err)}`);
       process.exit(1);
@@ -20110,7 +20696,7 @@ async function runCli(argv) {
       process.exit(1);
     }
     try {
-      const report = JSON.parse(await fs31.promises.readFile(path31.resolve(reportPath), "utf8"));
+      const report = JSON.parse(await fs32.promises.readFile(path32.resolve(reportPath), "utf8"));
       const repositoryIndex = argv.indexOf("--repository");
       const repository = repositoryIndex >= 0 ? argv[repositoryIndex + 1] : void 0;
       const evidence = buildCiEvidenceReport(report, { repository, runId: process.env.GITHUB_RUN_ID ?? process.env.CI_PIPELINE_ID });
@@ -20118,16 +20704,16 @@ async function runCli(argv) {
       const outputIndex = argv.indexOf("--out");
       const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : void 0;
       if (outputPath) {
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(outputPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(outputPath), `${JSON.stringify(evidence, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(outputPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(outputPath), `${JSON.stringify(evidence, null, 2)}
 `, "utf8");
       }
       const sarifIndex = argv.indexOf("--sarif-out");
       const sarifPath = sarifIndex >= 0 ? argv[sarifIndex + 1] : void 0;
       if (sarifPath) {
         const sarif = buildSarifReport(evidence, PACKAGE_VERSION);
-        await fs31.promises.mkdir(path31.dirname(path31.resolve(sarifPath)), { recursive: true });
-        await fs31.promises.writeFile(path31.resolve(sarifPath), `${JSON.stringify(sarif, null, 2)}
+        await fs32.promises.mkdir(path32.dirname(path32.resolve(sarifPath)), { recursive: true });
+        await fs32.promises.writeFile(path32.resolve(sarifPath), `${JSON.stringify(sarif, null, 2)}
 `, "utf8");
       }
       console.log(evidence.markdown);
@@ -20255,9 +20841,9 @@ async function runDoctor() {
   }
   let pwFound = false;
   try {
-    const cwdPkg = path31.resolve(process.cwd(), "package.json");
-    if (fs31.existsSync(cwdPkg)) {
-      const pkg = JSON.parse(fs31.readFileSync(cwdPkg, "utf-8"));
+    const cwdPkg = path32.resolve(process.cwd(), "package.json");
+    if (fs32.existsSync(cwdPkg)) {
+      const pkg = JSON.parse(fs32.readFileSync(cwdPkg, "utf-8"));
       const pwVer = pkg.devDependencies?.["@playwright/test"] || pkg.dependencies?.["@playwright/test"];
       if (pwVer) {
         console.log(`  \u2713 Playwright Test     : ${pwVer} (Found in package.json)`);
@@ -20280,7 +20866,7 @@ async function runDoctor() {
     }
   }
   try {
-    fs31.accessSync(process.cwd(), fs31.constants.W_OK);
+    fs32.accessSync(process.cwd(), fs32.constants.W_OK);
     console.log(`  \u2713 Workspace Access    : Read/Write verified for '${process.cwd()}'`);
   } catch {
     console.log(`  \u2717 Workspace Access    : Permission denied writing to '${process.cwd()}'`);
@@ -20554,6 +21140,7 @@ export {
   renderGitHubAnnotation,
   renderLocator,
   runAutonomousRepairWorkflow,
+  runBatchRepairWorkflow,
   runCli,
   runEvidenceDrivenGeneration,
   runGate,