filegrc 0.12.3 → 0.13.0

package/src/validate.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { performance } from "node:perf_hooks";
 import { getResourceDefinition, modelSupports } from "../model/index.js";
@@ -29,13 +30,31 @@ import { collectionReviewRevision, historicalCollectionReviewSnapshot } from "./
 import {
   reportingRouteRevision,
   reportingRouteBindingExpectationForValidation,
+  reportingRouteCommitTimestamp,
   reportingRouteEventCommit,
   reportingRouteEventAuthorityIssueAtCommit,
+  reportingRouteExactHistoryEntry,
   reportingRouteFixedEvidence,
-  reportingRouteRecordAtRevision
+  reportingRouteProposalIssues,
+  reportingRouteProposalAssessmentTime,
+  reportingRouteRecordAtRevision,
+  reportingRouteRequirementsForProposal,
+  reportingRouteSupportIssues,
+  recordsAtRevision
 } from "./reporting-route-integrity.js";
 import { validateWorkflowHistoryIntegrity } from "./workflow-history-integrity.js";
 
+let fingerprintFileReadObserver = null;
+
+export function setFingerprintFileReadObserverForTests(observer) {
+  if (observer !== null && typeof observer !== "function") {
+    throw new TypeError("The fingerprint file-read observer must be a function or null.");
+  }
+  const previous = fingerprintFileReadObserver;
+  fingerprintFileReadObserver = observer;
+  return () => { fingerprintFileReadObserver = previous; };
+}
+
 const ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const NAMESPACE_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/;
 const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
@@ -229,6 +248,7 @@ async function validateWorkspaceUnmeasured(input) {
         ));
       }
     } catch (cause) {
+      if (cause?.code === "FILEGRC_GIT_DEADLINE") throw cause;
       diagnostics.push(error(
         "reconciliation-history-unavailable",
         "data/workspace.json",
@@ -889,6 +909,29 @@ function validateReportingRouteSets(loaded, byId, pathById, diagnostics) {
   }
   for (const route of routeSets) {
     const path = pathById.get(route.id);
+    if (route.status === "proposed") {
+      const proposalHistory = repository.commit
+        ? reportingRouteExactHistoryEntry(loaded, route, repository.commit)
+        : null;
+      const proposalRecords = proposalHistory ? recordsAtRevision(loaded, proposalHistory.commit) : loaded.resources;
+      const proposalRecord = proposalHistory
+        ? proposalRecords.find(({ id }) => id === route.id) || route
+        : route;
+      const proposalAssessmentAt = proposalHistory
+        ? reportingRouteProposalAssessmentTime(proposalHistory.timestamp, new Date())
+        : new Date();
+      if (proposalHistory && !proposalAssessmentAt) {
+        diagnostics.push(error("invalid-reporting-route-proposal-time", path, "The proposal commit time is too far in the future to establish a reliable proposal."));
+      }
+      for (const issue of reportingRouteProposalIssues(proposalRecords, proposalRecord, {
+        at: proposalAssessmentAt || new Date(),
+        timezone: proposalRecords.find(({ type }) => type === "workspace")?.timezone || loaded.workspace?.timezone || "UTC",
+        root: loaded.root,
+        commit: proposalHistory?.commit
+      })) {
+        diagnostics.push(error(issue.code, path, issue.message));
+      }
+    }
     if (["draft", "proposed", "approved"].includes(route.status)) {
       const key = `${route.programId}\0${route.purposeKey}`;
       const current = currentByPurpose.get(key) || { approved: [], pending: [] };
@@ -924,6 +967,60 @@ function validateReportingRouteSets(loaded, byId, pathById, diagnostics) {
     const proposal = entry ? reportingRouteRecordAtRevision(loaded, entry, route.proposalCommit) : null;
     if (!proposal || proposal.status !== "proposed" || !sameRouteProposal(proposal, route)) {
       diagnostics.push(error("changed-reporting-route-proposal", path, "The approved Route Set facts must exactly match the committed proposal; only managed approval fields may differ."));
+    } else {
+      const proposalRecords = recordsAtRevision(loaded, route.proposalCommit);
+      const proposalTimestamp = reportingRouteCommitTimestamp(loaded, route.id, route.proposalCommit);
+      const proposalAssessmentAt = proposalTimestamp
+        ? reportingRouteProposalAssessmentTime(proposalTimestamp, new Date())
+        : null;
+      if (!proposalTimestamp) {
+        diagnostics.push(error("invalid-reporting-route-proposal", path, "The proposal commit must be an exact Reporting Channel Set history entry."));
+      } else if (!proposalAssessmentAt) {
+        diagnostics.push(error("invalid-reporting-route-proposal-time", path, "The proposal commit time is too far in the future to establish a reliable proposal."));
+      } else {
+        const proposalIssues = reportingRouteProposalIssues(
+          proposalRecords,
+          proposal,
+          {
+            at: proposalAssessmentAt,
+            timezone: proposalRecords.find(({ type }) => type === "workspace")?.timezone || loaded.workspace?.timezone || "UTC",
+            root: loaded.root,
+            commit: route.proposalCommit
+          }
+        );
+        for (const issue of proposalIssues) {
+          diagnostics.push(error(issue.code, path, issue.message));
+        }
+        if (!proposalIssues.length) {
+          const approvalCommit = reportingRouteEventCommit(loaded, route, "approval");
+          const approvalRecords = approvalCommit ? recordsAtRevision(loaded, approvalCommit) : loaded.resources;
+          const liveCommit = route.status === "canceled"
+            ? reportingRouteEventCommit(loaded, route, "cancellation")
+            : null;
+          const liveRecords = liveCommit ? recordsAtRevision(loaded, liveCommit) : loaded.resources;
+          const cutoverAt = route.approval?.effectiveAt || route.approval?.approvedAt || new Date();
+          const cutoverTimezone = route.approval?.timezone || loaded.workspace?.timezone || "UTC";
+          for (const issue of reportingRouteSupportIssues(
+            reportingRouteRequirementsForProposal(approvalRecords, route, {
+              at: cutoverAt,
+              timezone: cutoverTimezone
+            }),
+            route,
+            proposalRecords,
+            liveRecords,
+            {
+              at: cutoverAt,
+              availableAt: route.approval?.approvedAt || new Date(),
+              timezone: cutoverTimezone,
+              root: loaded.root,
+              proposalCommit: route.proposalCommit,
+              currentCommit: liveCommit
+            }
+          )) {
+            diagnostics.push(error(issue.code, path, issue.message));
+          }
+        }
+      }
     }
     for (const markdown of markdownEntries(loaded.model, route)) {
       const currentPath = `data/${markdown.path}`;
@@ -1224,19 +1321,27 @@ function validateCollectionReviewSet(resources, pathById, diagnostics) {
   }
 }
 
-export async function fingerprintWorkspace(input = process.cwd()) {
+export async function fingerprintWorkspace(input = process.cwd(), options = {}) {
   const loaded = typeof input === "object" && input.entries ? input : await loadWorkspace(input);
   const hash = createHash("sha256");
   hash.update(`model\0${loaded.model.modelVersion}\0`);
-  for (const entry of [...loaded.entries].sort((a, b) => a.relativePath.localeCompare(b.relativePath))) {
+  const sourceEntries = loaded.sourceEntries || loaded.entries;
+  const fingerprintBudget = { uncachedBytes: 0 };
+  for (const entry of [...sourceEntries].sort((a, b) => a.relativePath.localeCompare(b.relativePath))) {
     hash.update(`record\0${entry.relativePath}\0${entry.source.length}\0${entry.source}`);
+  }
+  for (const entry of [...loaded.entries].sort((a, b) => a.relativePath.localeCompare(b.relativePath))) {
     const definition = loaded.model.resources[entry.record?.type];
     if (!definition) continue;
     for (const item of markdownEntries(loaded.model, entry.record).sort((a, b) => a.path.localeCompare(b.path))) {
       try {
-        const source = await readFile(resolveDataPath(loaded.root, item.path), "utf8");
-        hash.update(`markdown\0${item.path}\0${source.length}\0${source}`);
-      } catch {
+        const resolvedPath = resolveDataPath(loaded.root, item.path);
+        const file = await stat(resolvedPath);
+        if (!file.isFile()) throw new Error("Markdown path is not a file.");
+        const content = await fingerprintFileContent(resolvedPath, file, options, fingerprintBudget);
+        hash.update(`markdown\0${item.path}\0${content.size}\0${content.digest}\0`);
+      } catch (error) {
+        if (error?.code === "FILEGRC_FINGERPRINT_BUDGET") throw error;
         hash.update(`markdown-missing\0${item.path}\0`);
       }
     }
@@ -1247,9 +1352,18 @@ export async function fingerprintWorkspace(input = process.cwd()) {
       const paths = Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
       for (const path of [...paths].sort()) {
         try {
-          const file = await stat(resolveDataPath(loaded.root, path));
-          hash.update(`data-path\0${path}\0${file.isFile() ? "file" : "other"}\0`);
-        } catch {
+          const resolvedPath = resolveDataPath(loaded.root, path);
+          const file = await stat(resolvedPath);
+          if (file.isFile()) {
+            const identity = `${file.dev}:${file.ino}:${file.mode}:${file.size}:${file.mtimeMs}:${file.ctimeMs}`;
+            let content = options.fileDigestCache?.get(resolvedPath);
+            if (!content || content.identity !== identity) {
+              content = await fingerprintFileContent(resolvedPath, file, options, fingerprintBudget);
+            }
+            hash.update(`data-path\0${path}\0file\0${content.size}\0${content.digest}\0`);
+          } else hash.update(`data-path\0${path}\0other\0`);
+        } catch (error) {
+          if (error?.code === "FILEGRC_FINGERPRINT_BUDGET") throw error;
           hash.update(`data-path-missing\0${path}\0`);
         }
       }
@@ -1258,6 +1372,41 @@ export async function fingerprintWorkspace(input = process.cwd()) {
   return { fingerprint: hash.digest("hex"), loaded };
 }
 
+async function fingerprintFileContent(path, file, options, budget) {
+  const identity = `${file.dev}:${file.ino}:${file.mode}:${file.size}:${file.mtimeMs}:${file.ctimeMs}`;
+  const cached = options.fileDigestCache?.get(path);
+  if (cached?.identity === identity) return cached;
+  assertFingerprintBudget(options, budget.uncachedBytes + file.size);
+  budget.uncachedBytes += file.size;
+  const contentHash = createHash("sha256");
+  let size = 0;
+  await fingerprintFileReadObserver?.(path);
+  for await (const chunk of createReadStream(path)) {
+    assertFingerprintBudget(options, budget.uncachedBytes - file.size + size + chunk.length);
+    size += chunk.length;
+    contentHash.update(chunk);
+  }
+  const content = { identity, size, digest: contentHash.digest("hex") };
+  if (options.fileDigestCache?.size < 20_000 || options.fileDigestCache?.has(path)) {
+    options.fileDigestCache.set(path, content);
+  }
+  return content;
+}
+
+function assertFingerprintBudget(options, uncachedBytes) {
+  if (options.deadlineAt !== undefined && performance.now() >= options.deadlineAt) {
+    const error = new Error("Workspace attachment verification exceeded its time limit. Reload and try again.");
+    error.code = "FILEGRC_FINGERPRINT_BUDGET";
+    throw error;
+  }
+  if (options.maxUncachedFileBytes !== undefined
+    && uncachedBytes > options.maxUncachedFileBytes) {
+    const error = new Error("Workspace file verification exceeded its byte limit. Reload and try again.");
+    error.code = "FILEGRC_FINGERPRINT_BUDGET";
+    throw error;
+  }
+}
+
 function validateImplementedControlSchedules(record, obligationsByControl, path, diagnostics) {
   if (record.type !== "control" || record.status !== "implemented") return;
   const schedules = obligationsByControl.get(record.id) || [];

package/src/web.js

@@ -95,6 +95,7 @@ let repositorySyncPollInFlight = false;
 let mutationStateRefreshInFlight = false;
 let mutationStateRefreshTimer = null;
 let programSelectionGeneration = 0;
+let expiredStateRefresh = null;
 
 start().catch((error) => {
   root.innerHTML = '<main class="fatal"><h1>Could Not Load the Workspace</h1><pre></pre></main>';
@@ -173,7 +174,7 @@ function desiredStateSections(route) {
   const sections = new Set(["repository", ...blockingStateSections(route)]);
   if (route.name === "list" && (["requirement", "requirement-mapping"].includes(route.type) || state.model.collectionReviews?.[route.type])) sections.add("program");
   if (route.name === "detail" && ["policy", "document", "training", "control", "component", "requirement-mapping", "retention-schedule-item"].includes(route.type)) sections.add("program");
-  if (route.name === "detail" && ["policy", "document", "framework", "requirement", "commitment", "system", "component", "vendor", "information-type", "source-coverage", "requirement-mapping", "retention-schedule-item"].includes(route.type)) sections.add("workflow");
+  if (route.name === "detail") sections.add("workflow");
   if (route.name === "detail" && ["obligation", "action-item", "obligation-event"].includes(route.type)) sections.add("obligations");
   if (route.name === "detail" && route.type === "audit") sections.add("audits");
   return [...sections];
@@ -193,14 +194,22 @@ function loadStateForRoute() {
   for (const section of desiredStateSections(route)) loadStateSection(section);
 }
 
-function loadStateSection(section) {
+function loadStateSection(section, refreshExpired = true) {
   if (!state.stateToken || state.sections?.[section] === "complete") return Promise.resolve();
   if (stateSectionRequests.has(section)) return stateSectionRequests.get(section);
   state.sections[section] = "loading";
   const token = state.stateToken;
   const programQuery = state.selectedProgramId ? "&programId=" + encodeURIComponent(state.selectedProgramId) : "";
-  const request = fetchJson("/api/state/" + encodeURIComponent(section) + "?token=" + encodeURIComponent(token) + programQuery)
-    .then((result) => {
+  const request = localFetch("/api/state/" + encodeURIComponent(section) + "?token=" + encodeURIComponent(token) + programQuery)
+    .then(async (response) => {
+      if (response.status === 409 && refreshExpired && state.stateToken === token) {
+        await refreshExpiredAppState(token);
+        render();
+        if (stateSectionRequests.get(section) === request) stateSectionRequests.delete(section);
+        return loadStateSection(section, false);
+      }
+      if (!response.ok) throw new Error(await responseMessage(response));
+      const result = await response.json();
       if (state.stateToken !== result.stateToken) return;
       Object.assign(state, result.state);
       state.sections[section] = "complete";
@@ -992,10 +1001,12 @@ function workflowItemHref(item) {
   if (source && ["assigned-work", "obligation-occurrence"].includes(item.kind)) {
     return "#/stage/run?work=" + encodeURIComponent(source.type + ":" + source.id);
   }
-  const commands = [
-    ...(item.actions || []).map((action) => action.command),
-    item.nextAction?.command
-  ].filter(Boolean);
+  const actions = [...(item.actions || []), item.nextAction].filter(Boolean);
+  const reconciliationAction = actions.find((action) => action.kind === "reconcile-transition");
+  if (reconciliationAction?.candidateId) {
+    return "#/stage/run?reconcile=" + encodeURIComponent(reconciliationAction.candidateId);
+  }
+  const commands = actions.map((action) => action.command).filter(Boolean);
   if (item.createResourceType && state.model.resources[item.createResourceType]) {
     const params = new URLSearchParams({ new: "1" });
     if (item.title) params.set("title", item.createResourceType === "commitment"
@@ -1603,6 +1614,16 @@ function renderObligations(main, params = new URLSearchParams()) {
       if (requestedEvent) main.querySelector('[data-start-event="' + CSS.escape(requestedEvent) + '"]')?.click();
     });
   }
+  const requestedReconciliation = params.get("reconcile");
+  if (requestedReconciliation) {
+    queueMicrotask(() => {
+      const candidate = state.reconciliation?.candidates?.find((item) => (
+        item.transitionFingerprint === requestedReconciliation
+        || item.id === requestedReconciliation
+      ));
+      if (candidate) openReconciliationConfirmation(candidate);
+    });
+  }
   const requestedWork = params.get("work");
   if (requestedWork) {
     queueMicrotask(() => {
@@ -2909,17 +2930,35 @@ function evidenceAttachmentPanel(entry) {
 }
 
 async function loadResourceDetail(type, id) {
-  const key = type + "\0" + id;
+  const key = (state.stateToken || "live") + "\0" + type + "\0" + id;
   if (resourceDetailRequests.has(key)) return resourceDetailRequests.get(key);
   const request = (async () => {
     try {
-      const response = await localFetch("/api/resource/" + encodeURIComponent(type) + "/" + encodeURIComponent(id));
-      if (!response.ok) throw new Error(await responseMessage(response));
-      const detail = await response.json();
+      let token = state.stateToken;
+      let detail = null;
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        const tokenQuery = token ? "?token=" + encodeURIComponent(token) : "";
+        const response = await localFetch("/api/resource/" + encodeURIComponent(type) + "/" + encodeURIComponent(id) + tokenQuery);
+        if (response.status === 409 && token) {
+          await refreshExpiredAppState(token);
+          token = state.stateToken;
+          continue;
+        }
+        if (!response.ok) throw new Error(await responseMessage(response));
+        detail = await response.json();
+        if (!token || (detail.stateToken === token && state.stateToken === token)) break;
+        token = state.stateToken;
+        detail = null;
+      }
+      if (!detail) throw new Error("The workspace state changed while loading this record. Reload and try again.");
+      delete detail.stateToken;
       const index = state.resources.findIndex(({ record }) => record.type === type && record.id === id);
       if (index >= 0) state.resources[index] = detail;
       const route = parseRoute();
-      if (route.name === "detail" && route.type === type && route.id === id) render();
+      if (route.name === "detail" && route.type === type && route.id === id) {
+        render();
+        loadStateForRoute();
+      }
     } catch (error) {
       const route = parseRoute();
       if (route.name === "detail" && route.type === type && route.id === id) {
@@ -2927,13 +2966,52 @@ async function loadResourceDetail(type, id) {
         if (main) main.innerHTML = '<div class="page"><section class="panel"><div class="dialog-error" role="alert">' + esc(error.message) + '</div></section></div>';
       }
     } finally {
-      resourceDetailRequests.delete(key);
+      for (const [requestKey, pending] of resourceDetailRequests) {
+        if (pending === request) resourceDetailRequests.delete(requestKey);
+      }
     }
   })();
   resourceDetailRequests.set(key, request);
   return request;
 }
 
+function refreshExpiredAppState(expectedToken) {
+  if (expiredStateRefresh) {
+    if (expiredStateRefresh.token === expectedToken) return expiredStateRefresh.promise;
+    return expiredStateRefresh.promise
+      .catch(() => {})
+      .then(() => refreshExpiredAppState(expectedToken));
+  }
+  if (expectedToken && state.stateToken !== expectedToken) return Promise.resolve();
+  const programQuery = state.selectedProgramId ? "?programId=" + encodeURIComponent(state.selectedProgramId) : "";
+  const holder = { token: expectedToken, promise: null };
+  const refresh = (async () => {
+    const response = await fetch("/api/state/bootstrap" + programQuery);
+    if (!response.ok) throw new Error(await responseMessage(response));
+    const next = normalizeAppState(await response.json());
+    if (expectedToken && state.stateToken !== expectedToken) return;
+    rekeyResourceDetailRequests(state.stateToken, next.stateToken);
+    state = next;
+    stateSectionRequests.clear();
+  })().finally(() => {
+    if (expiredStateRefresh === holder) expiredStateRefresh = null;
+  });
+  holder.promise = refresh;
+  expiredStateRefresh = holder;
+  return refresh;
+}
+
+function rekeyResourceDetailRequests(previousToken, nextToken) {
+  if (!previousToken || !nextToken || previousToken === nextToken) return;
+  const prefix = previousToken + "\0";
+  for (const [key, request] of resourceDetailRequests) {
+    if (!key.startsWith(prefix)) continue;
+    const nextKey = nextToken + key.slice(previousToken.length);
+    resourceDetailRequests.delete(key);
+    if (!resourceDetailRequests.has(nextKey)) resourceDetailRequests.set(nextKey, request);
+  }
+}
+
 function issueSeed(type, source) {
   const owners = source.ownerIds || source.reviewerIds || source.assessorIds || source.testerIds || [];
   if (type === "finding") {
@@ -3208,6 +3286,67 @@ function openReconciliationDismissal(candidate) {
   });
 }
 
+function openReconciliationConfirmation(candidate) {
+  if (document.querySelector('[data-reconciliation-confirmation="' + CSS.escape(candidate.transitionFingerprint) + '"]')) return;
+  const writeDisabled = state.readOnly
+    ? ' disabled title="Writes are not available in this repository state"'
+    : "";
+  const needsTimestamp = (candidate.requiredFacts || []).includes("occurredAt");
+  const eventField = needsTimestamp
+    ? '<label><span>Event time <small>your local time</small></span><input name="occurredAt" type="datetime-local" required value="' + esc(currentLocalDateTime()) + '"></label>'
+    : '<label><span>Event date</span><input name="occurredOn" type="date" required value="' + esc(currentDate()) + '"></label>';
+  const riskField = (candidate.requiredFacts || []).includes("riskLevel")
+    ? '<label><span>Departure risk</span><select name="riskLevel" required><option value="normal">Normal</option><option value="high">High or involuntary</option></select></label>'
+    : "";
+  const dialog = document.createElement("dialog");
+  dialog.className = "commit-dialog event-dialog";
+  dialog.dataset.reconciliationConfirmation = candidate.transitionFingerprint;
+  dialog.setAttribute("aria-labelledby", "reconciliation-confirmation-title");
+  dialog.innerHTML = '<form><div class="dialog-head"><div><p class="kicker">Git transition review</p><h2 id="reconciliation-confirmation-title">' + esc(policyEventName(candidate.eventType)) + '</h2></div><button type="button" class="icon-button" aria-label="Close">×</button></div><p>' + esc(candidate.message) + '</p><section class="event-dialog-steps"><div><strong>' + esc(candidate.subject.title || candidate.subject.id) + '</strong><small>' + esc(candidate.sourcePath) + '</small></div></section>' + eventField + riskField + '<label><span>Workflow name <small>optional</small></span><input name="title" maxlength="200" placeholder="' + esc(policyEventName(candidate.eventType)) + '"' + writeDisabled + '></label>' + (state.readOnly ? '<p class="dialog-note">Open this workspace in the local writable renderer or use the CLI to confirm or dismiss this transition.</p>' : "") + '<div class="dialog-error" role="alert"></div><div class="save-status" role="status" aria-live="polite"></div><div class="dialog-actions"><button type="button" class="button" data-dismiss-candidate' + writeDisabled + '>Dismiss false positive</button><button type="button" class="button" data-dismiss-dialog>Cancel</button><button type="submit" class="button primary"' + writeDisabled + '>Confirm and add work</button></div></form>';
+  document.body.append(dialog);
+  dialog.showModal();
+  dialog.querySelector(".icon-button").addEventListener("click", () => dialog.close());
+  dialog.querySelector("[data-dismiss-dialog]").addEventListener("click", () => dialog.close());
+  dialog.querySelector("[data-dismiss-candidate]").addEventListener("click", () => {
+    dialog.close();
+    openReconciliationDismissal(candidate);
+  });
+  dialog.addEventListener("close", () => dialog.remove());
+  dialog.querySelector("form").addEventListener("submit", async (event) => {
+    event.preventDefault();
+    const form = event.currentTarget;
+    if (!form.reportValidity()) return;
+    try {
+      setMutationBusy(dialog, true, "Confirming…", "Confirm and add work");
+      const response = await localFetch("/api/reconciliation", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          candidateId: candidate.transitionFingerprint,
+          occurredOn: form.elements.occurredOn?.value || undefined,
+          occurredAt: form.elements.occurredAt?.value ? new Date(form.elements.occurredAt.value).toISOString() : undefined,
+          riskLevel: form.elements.riskLevel?.value || undefined,
+          title: form.elements.title.value,
+          confirmed: true
+        })
+      });
+      if (!response.ok) throw new Error(await responseMessage(response));
+      const created = await response.json();
+      policyEventFeedback = {
+        name: policyEventName(candidate.eventType),
+        taskCount: created.actions?.length || 0
+      };
+      applyMutationState(created);
+      dialog.close();
+      history.replaceState(null, "", "#/stage/run");
+      render();
+    } catch (error) {
+      setMutationBusy(dialog, false, "", "Confirm and add work");
+      dialog.querySelector(".dialog-error").textContent = error.message;
+    }
+  });
+}
+
 async function runRepositoryGitAction(action) {
   const buttons = [...document.querySelectorAll("[data-git-action]")];
   const disabled = buttons.map((button) => button.disabled);

package/src/workflow-history-integrity.js

@@ -116,7 +116,7 @@ export async function validateWorkflowHistoryIntegrity(loaded, diagnostics) {
       entry.record.type === "exception"
       && historical.record.reportingRouteSetId
       && historical.commit !== commits.find((commit) => {
-        try { return Number(JSON.parse(getFileAtRevision(loaded.root, commit, "data/workspace.json"))?.dataModelVersion) >= 10; } catch { return false; }
+        try { return Number(JSON.parse(getFileAtRevision(loaded.root, commit, "data/workspace.json"))?.dataModelVersion) >= 10; } catch (error) { rethrowGitDeadline(error); return false; }
       })
     ) {
       const records = recordsAtRevision(loaded, historical.commit);
@@ -146,7 +146,7 @@ export async function validateWorkflowHistoryIntegrity(loaded, diagnostics) {
   }
 
   const firstV10Commit = commits.find((commit) => {
-    try { return Number(JSON.parse(getFileAtRevision(loaded.root, commit, "data/workspace.json"))?.dataModelVersion) >= 10; } catch { return false; }
+    try { return Number(JSON.parse(getFileAtRevision(loaded.root, commit, "data/workspace.json"))?.dataModelVersion) >= 10; } catch (error) { rethrowGitDeadline(error); return false; }
   });
   const protectedRouteSources = new Map();
   for (const [commit, records] of revisionRecords) {
@@ -307,7 +307,8 @@ function legacyCollectionReviewTransition(loaded, previous, current) {
   try {
     const workspace = JSON.parse(getFileAtRevision(loaded.root, current.commit, "data/workspace.json"));
     return Number(workspace?.dataModelVersion) < 9;
-  } catch {
+  } catch (error) {
+    rethrowGitDeadline(error);
     return false;
   }
 }
@@ -319,7 +320,8 @@ function historicalState(loaded) {
     try {
       const workspace = JSON.parse(getFileAtRevision(loaded.root, commit, "data/workspace.json"));
       return Number(workspace?.dataModelVersion) >= 9;
-    } catch {
+    } catch (error) {
+      rethrowGitDeadline(error);
       return false;
     }
   });
@@ -392,7 +394,8 @@ function legacyCollectionReview(loaded, historical) {
   let workspace;
   try {
     workspace = JSON.parse(getFileAtRevision(loaded.root, historical.commit, "data/workspace.json"));
-  } catch {
+  } catch (error) {
+    rethrowGitDeadline(error);
     return false;
   }
   return Number(workspace?.dataModelVersion) < 9
@@ -408,7 +411,8 @@ function recordAtRevision(loaded, commit, id, identityHistory) {
   try {
     const record = JSON.parse(source);
     return record?.id === id ? { record, path: item.path } : null;
-  } catch {
+  } catch (error) {
+    rethrowGitDeadline(error);
     return null;
   }
 }
@@ -454,7 +458,7 @@ async function validateReportingRouteAuthorityHistory(loaded, commits, revisionR
   ));
   if (!routeSets.length) return;
   const firstV10Commit = commits.find((commit) => {
-    try { return Number(JSON.parse(getFileAtRevision(loaded.root, commit, "data/workspace.json"))?.dataModelVersion) >= 10; } catch { return false; }
+    try { return Number(JSON.parse(getFileAtRevision(loaded.root, commit, "data/workspace.json"))?.dataModelVersion) >= 10; } catch (error) { rethrowGitDeadline(error); return false; }
   });
   for (const route of routeSets) {
     const versions = changedVersions(route.id, commits, revisionRecords, historiesById);
@@ -733,7 +737,8 @@ function authorityAppointmentOverlapsRoute(appointment, route, workspaceId, time
     routeEnd = route.cancellation?.canceledAt
       ? currentCalendarDate(timezone, new Date(route.cancellation.canceledAt))
       : null;
-  } catch {
+  } catch (error) {
+    rethrowGitDeadline(error);
     return false;
   }
   return (!routeEnd || appointment.startsOn <= routeEnd)
@@ -786,7 +791,8 @@ function historicalWorkspaceTimezoneAtRevision(loaded, commit) {
     if (typeof workspace?.timezone !== "string" || !workspace.timezone.trim()) return null;
     new Intl.DateTimeFormat("en", { timeZone: workspace.timezone }).format();
     return workspace.timezone;
-  } catch {
+  } catch (error) {
+    rethrowGitDeadline(error);
     return null;
   }
 }
@@ -901,3 +907,7 @@ function integrityError(entry, message) {
     message
   };
 }
+
+function rethrowGitDeadline(error) {
+  if (error?.code === "FILEGRC_GIT_DEADLINE") throw error;
+}

package/src/workflow.js

@@ -141,7 +141,9 @@ async function assessWorkflowUnmeasured(input, options = {}) {
     asOf,
     evaluatedAt,
     programId: programRecord.type === "program" ? programRecord.id : undefined,
-    controlIds: options.auditId ? audits[0]?.controlIds : programRecord?.controlIds
+    controlIds: options.auditId ? audits[0]?.controlIds : programRecord?.controlIds,
+    historyDeadlineAt: options.historyDeadlineAt,
+    strictHistory: options.strictHistory
   });
   const guidedFindings = [
     ...programFindings(program),
@@ -732,7 +734,10 @@ async function assessPeriodHealth(loaded, options) {
     "component"
   ].includes(record.type));
   const paths = relevantEntries.map(({ relativePath }) => `data/${relativePath}`);
-  const histories = getWorkspaceHistories(loaded.root, paths, 50);
+  const histories = getWorkspaceHistories(loaded.root, paths, 50, {
+    deadlineAt: options.historyDeadlineAt,
+    strict: options.strictHistory === true
+  });
   const allHistory = [...histories.values()].flat().filter(Boolean);
   const earliestCommitDate = allHistory
     .map(({ timestamp }) => timestamp?.slice(0, 10))

package/src/workspace.js

@@ -14,11 +14,13 @@ async function loadWorkspaceUnmeasured(input) {
   const diagnostics = [];
   const files = await collectJsonFiles(dataRoot);
   const resources = [];
+  const sourceEntries = [];
 
   for (const path of files) {
     const relativePath = relative(dataRoot, path).split(sep).join("/");
     try {
       const source = await readFile(path, "utf8");
+      sourceEntries.push({ path, relativePath, source });
       const record = JSON.parse(source);
       resources.push({ record, path, relativePath, source });
     } catch (error) {
@@ -68,6 +70,7 @@ async function loadWorkspaceUnmeasured(input) {
     model,
     workspace: workspaceEntry?.record ?? null,
     entries: resources,
+    sourceEntries,
     resources: resources.map(({ record }) => record),
     diagnostics
   };