@xenonbyte/da-vinci-workflow 0.2.3 → 0.2.4

package/lib/verify.js

@@ -13,6 +13,7 @@ const {
   readChangeArtifacts,
   readArtifactTexts
 } = require("./planning-parsers");
+const { readExecutionSignals, summarizeSignalsBySurface } = require("./execution-signals");
 
 const CODE_FILE_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx", ".html", ".css", ".scss"]);
 const NON_IMPLEMENTATION_DIR_NAMES = new Set([
@@ -47,6 +48,7 @@ const MAX_SCANNED_FILES = 2000;
 const MAX_SCANNED_BYTES_PER_FILE = 512 * 1024;
 const MAX_SCANNED_DIRECTORIES = 10000;
 const MAX_SCAN_DEPTH = 32;
+const DEFAULT_EVIDENCE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 
 function buildEnvelope(name, projectRoot, strict) {
   return {
@@ -226,6 +228,138 @@ function allCovered(checks) {
   return true;
 }
 
+function safeMtimeMs(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    return Number(stat.mtimeMs) || 0;
+  } catch (_error) {
+    return 0;
+  }
+}
+
+function collectFreshnessBaseline(projectRoot, resolved, artifactPaths) {
+  const baselineCandidates = [];
+  if (artifactPaths) {
+    baselineCandidates.push(
+      artifactPaths.proposalPath,
+      artifactPaths.tasksPath,
+      artifactPaths.bindingsPath,
+      artifactPaths.pencilDesignPath,
+      artifactPaths.verificationPath
+    );
+  }
+  if (resolved && resolved.changeDir) {
+    const specsRoot = path.join(resolved.changeDir, "specs");
+    if (fs.existsSync(specsRoot)) {
+      const stack = [specsRoot];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        let entries = [];
+        try {
+          entries = fs.readdirSync(current, { withFileTypes: true });
+        } catch (_error) {
+          continue;
+        }
+        for (const entry of entries) {
+          const absolutePath = path.join(current, entry.name);
+          if (entry.isDirectory() && !entry.isSymbolicLink()) {
+            stack.push(absolutePath);
+            continue;
+          }
+          if (entry.isFile() && entry.name === "spec.md") {
+            baselineCandidates.push(absolutePath);
+          }
+        }
+      }
+    }
+  }
+  const baselineMs = baselineCandidates.reduce((latest, candidate) => Math.max(latest, safeMtimeMs(candidate)), 0);
+  return {
+    baselineMs,
+    baselineIso: baselineMs > 0 ? new Date(baselineMs).toISOString() : ""
+  };
+}
+
+function collectVerificationFreshness(projectPathInput, options = {}) {
+  const projectRoot = path.resolve(projectPathInput || process.cwd());
+  const changeId = options.changeId ? String(options.changeId).trim() : "";
+  if (!changeId) {
+    return {
+      fresh: false,
+      changeId: null,
+      requiredSurfaces: [],
+      surfaces: {},
+      staleReasons: ["Missing change id for verification freshness checks."],
+      baselineIso: ""
+    };
+  }
+
+  const requiredSurfaces =
+    Array.isArray(options.requiredSurfaces) && options.requiredSurfaces.length > 0
+      ? options.requiredSurfaces
+      : ["verify-bindings", "verify-implementation", "verify-structure", "verify-coverage"];
+  const maxAgeMs =
+    Number.isFinite(Number(options.maxAgeMs)) && Number(options.maxAgeMs) > 0
+      ? Number(options.maxAgeMs)
+      : DEFAULT_EVIDENCE_MAX_AGE_MS;
+  const nowMs = Date.now();
+  const signals = readExecutionSignals(projectRoot, { changeId });
+  const summary = summarizeSignalsBySurface(signals);
+  const baseline = collectFreshnessBaseline(projectRoot, options.resolved, options.artifactPaths);
+  const staleReasons = [];
+  const surfaces = {};
+
+  for (const surface of requiredSurfaces) {
+    const key = String(surface || "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+    const signal = summary[key];
+    if (!signal) {
+      staleReasons.push(`Missing evidence signal: ${surface}.`);
+      surfaces[surface] = {
+        present: false,
+        stale: true
+      };
+      continue;
+    }
+    const timestampMs = Date.parse(String(signal.timestamp || ""));
+    if (!Number.isFinite(timestampMs)) {
+      staleReasons.push(`Invalid evidence timestamp for ${surface}.`);
+      surfaces[surface] = {
+        present: true,
+        stale: true,
+        timestamp: signal.timestamp || ""
+      };
+      continue;
+    }
+    const olderThanBaseline = baseline.baselineMs > 0 && timestampMs < baseline.baselineMs;
+    const olderThanMaxAge = nowMs - timestampMs > maxAgeMs;
+    if (olderThanBaseline) {
+      staleReasons.push(
+        `${surface} evidence is older than current artifact baseline (${new Date(timestampMs).toISOString()} < ${baseline.baselineIso}).`
+      );
+    }
+    if (olderThanMaxAge) {
+      staleReasons.push(
+        `${surface} evidence is older than freshness window (${Math.round((nowMs - timestampMs) / 1000)}s).`
+      );
+    }
+    surfaces[surface] = {
+      present: true,
+      stale: olderThanBaseline || olderThanMaxAge,
+      status: signal.status,
+      timestamp: signal.timestamp
+    };
+  }
+
+  return {
+    fresh: staleReasons.length === 0,
+    changeId,
+    requiredSurfaces,
+    surfaces,
+    staleReasons: unique(staleReasons),
+    baselineIso: baseline.baselineIso
+  };
+}
+
 function createSharedSetup(projectPathInput, options = {}) {
   const projectRoot = path.resolve(projectPathInput || process.cwd());
   const strict = options && options.strict === true;
@@ -600,6 +734,22 @@ function verifyCoverage(projectPathInput, options = {}) {
     }
   };
 
+  const freshness = collectVerificationFreshness(projectRoot, {
+    changeId: result.changeId,
+    resolved: sharedSetup.resolved,
+    artifactPaths: sharedSetup.artifactPaths,
+    requiredSurfaces: ["verify-bindings", "verify-implementation", "verify-structure"]
+  });
+  result.freshness = freshness;
+  if (!freshness.fresh) {
+    result.warnings.push(
+      "Verification freshness is stale for completion-facing claims; re-run verify surfaces before completion wording."
+    );
+    for (const reason of freshness.staleReasons) {
+      result.warnings.push(reason);
+    }
+  }
+
   return finalize(result);
 }
 
@@ -648,5 +798,6 @@ module.exports = {
   verifyImplementation,
   verifyStructure,
   verifyCoverage,
-  formatVerifyReport
+  formatVerifyReport,
+  collectVerificationFreshness
 };