filegrc 0.15.1 → 0.15.2

package/model/v11.json

@@ -567,7 +567,7 @@
     },
     "vendor": {
       "title": "Vendor inventory",
-      "description": "Confirm material external provider relationships separately from Program System and Component scope.",
+      "description": "Finish each material external provider record, then confirm the Vendor inventory once as a complete collection separate from Program System and Component scope.",
       "reviewPoints": [
         "Add Vendors for material external commercial or service relationships.",
         "Confirm contracts, due diligence, criticality, information access, and monitoring.",
@@ -593,7 +593,7 @@
     },
     "complementary-control": {
       "title": "Customer and provider responsibilities",
-      "description": "Confirm whether any in-scope Control depends on a customer or carved-out provider action, including when no such dependency exists.",
+      "description": "Finish each customer or carved-out provider responsibility record, then confirm the collection once, including when no such dependency exists.",
       "reviewPoints": [
         "Think through the customer and carved-out provider actions that in-scope Controls depend on, and add any missing Complementary Control.",
         "Confirm each statement names a specific action, responsible party, affected System, and dependent Control.",
@@ -606,7 +606,7 @@
     },
     "component": {
       "title": "Scoped Components",
-      "description": "Confirm the Components that materially participate in the selected Program Systems.",
+      "description": "Finish each Component proposal, then confirm once that the collection materially participating in the selected Program Systems is complete.",
       "reviewPoints": [
         "Start with each bounded System and include only Components that deliver its service, support Controls, produce authoritative Evidence, or support relevant operations.",
         "Confirm every System use has the right role and a specific rationale.",
@@ -631,7 +631,7 @@
     },
     "information-type": {
       "title": "Information Type inventory",
-      "description": "Confirm that Information Types are complete, distinct, and linked to the Systems, Components, and Vendors that use or access them.",
+      "description": "Finish each Information Type proposal, then confirm once that the collection is complete, distinct, and linked to the Systems, Components, and Vendors that use or access it.",
       "reviewPoints": [
         "Review near-duplicate names and choose one canonical Information Type only after confirming they mean the same thing.",
         "Retire superseded records through a reviewed migration that rewrites every relationship.",
@@ -644,11 +644,11 @@
     },
     "retention-schedule-item": {
       "title": "Data Retention Schedule",
-      "description": "Approve the schedule document and its structured rows as one governed schedule. Include only actual information uses and keep undecided organization values planned.",
+      "description": "Complete each structured row proposal, then approve the schedule document and all proposed rows in one independent review. Include only actual information uses and keep undecided organization values planned.",
       "reviewPoints": [
-        "Review the Data Retention Schedule document, its Markdown, and every included structured row as one revision.",
+        "Confirm the owner completed every row proposal, then review the Data Retention Schedule document, its Markdown, and every proposed row as one revision.",
         "Confirm schedule coverage across the Systems, Components, Vendors, source families, logs, backups, audit records, and FileGRC records the organization actually uses.",
-        "Confirm every active item has an approved cutoff, retention period, disposition action, owner, approver, and exact reviewed source revisions; keep undecided behavior planned."
+        "Confirm every proposed item has a reviewed cutoff, retention period, disposition action, owner, and exact source revisions; keep undecided behavior planned."
       ],
       "decisions": [
         "complete",
@@ -7699,14 +7699,14 @@
       "pluralTitle": "Retention Schedule",
       "group": "governance",
       "collection": "retention-schedule-items",
-      "description": "One reviewed schedule item that states which Information Types and operational scope it covers, when retention starts, how long information is kept, and its approved disposition.",
+      "description": "One owner-completed proposal that states which Information Types and operational scope it covers, when retention starts, how long information is kept, and its proposed disposition. It becomes authoritative through the single whole-schedule approval.",
       "guidance": {
         "policyBasis": "Management must translate legal, contractual, privacy, security, and business needs into explicit retention and disposition instructions without treating starter periods as organization facts.",
-        "cadence": "Review before activation and after a source Policy, Requirement, Commitment, information use, System, Component, Vendor, or legal-hold process changes.",
+        "cadence": "Complete the proposal before whole-schedule approval and revisit it after a source Policy, Requirement, Commitment, information use, System, Component, Vendor, or legal-hold process changes.",
         "reviewPoints": [
           "Confirm the Information Types and operational scope covered by this item.",
-          "Confirm the cutoff, retention period, and disposition action from approved management sources.",
-          "Keep the item planned until management approves every organization-specific value."
+          "Confirm the cutoff, retention period, and disposition action from management sources.",
+          "Keep the item planned until the owner completes every organization-specific value and binds the current source revisions."
         ],
         "sourceResourceIds": [
           "policy-information-security",
@@ -7828,16 +7828,11 @@
           "relation": [
             "person"
           ],
-          "requiredWhen": {
-            "status": "active"
-          },
-          "label": "Approved by"
+          "label": "Legacy row reviewer"
         },
         "approvedOn": {
           "type": "date",
-          "requiredWhen": {
-            "status": "active"
-          }
+          "label": "Legacy row review date"
         },
         "reviewedSourceRevisions": {
           "type": "object",
@@ -7891,8 +7886,6 @@
         "retentionPeriod",
         "dispositionAction",
         "dispositionInstructions",
-        "approvedByIds",
-        "approvedOn",
         "reviewedSourceRevisions",
         "supersedesId",
         "statusTransition"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filegrc",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "Zero-dependency Git-native GRC engine",
   "license": "MIT",
   "repository": {

package/src/audit-preparation.js

@@ -105,17 +105,21 @@ export async function assessAuditPreparation(input, options = {}) {
   }
   const items = stages.flatMap((stage) => stage.items);
   const counts = countStatuses(items);
-  const managedItems = items.filter((item) => !["external", "info", "later"].includes(item.status));
-  const completedManagedItems = managedItems.filter((item) => item.status === "complete");
+  const progressUnits = items.flatMap((current) => (
+    current.progressUnit === false || ["external", "info", "later"].includes(current.status)
+      ? []
+      : current.progressUnits?.length ? current.progressUnits : [current]
+  )).filter((current) => !["external", "info", "later"].includes(current.status));
+  const completedProgressUnits = progressUnits.filter((current) => current.status === "complete");
   return {
     schemaVersion: 1,
     generatedAt: options.generatedAt || new Date().toISOString(),
     audit: audit ? auditSummary(audit) : null,
     status: !audit ? "not-started" : counts.action ? "needs-work" : "management-ready",
     progress: {
-      complete: completedManagedItems.length,
-      total: managedItems.length,
-      percent: managedItems.length ? Math.round((completedManagedItems.length / managedItems.length) * 100) : 0
+      complete: completedProgressUnits.length,
+      total: progressUnits.length,
+      percent: progressUnits.length ? Math.round((completedProgressUnits.length / progressUnits.length) * 100) : 0
     },
     counts,
     canInitialize: Boolean(audit
@@ -965,7 +969,7 @@ function occurrenceContinuityStage(audit, records, model, asOf) {
   const gapStatuses = new Set(["overdue", "blocked", "due", "proposed"]);
   const calendarGaps = plan.calendarItems.filter(({ status }) => gapStatuses.has(status));
   const eventGaps = plan.eventRuns
-    .filter((run) => run.occurredOn >= periodStart && run.occurredOn <= periodThrough)
+    .filter((run) => run.status !== "canceled" && run.occurredOn >= periodStart && run.occurredOn <= periodThrough)
     .flatMap((run) => run.actions)
     .filter((action) => (
       (gapStatuses.has(action.status) || action.lateCompletion)
@@ -974,6 +978,57 @@ function occurrenceContinuityStage(audit, records, model, asOf) {
   const gaps = [...calendarGaps, ...eventGaps];
   const lateGaps = eventGaps.filter(({ lateCompletion }) => lateCompletion);
   const firstGap = gaps[0];
+  const progressUnits = occurrenceProgressUnits(plan, {
+    selectedControlIds,
+    periodStart,
+    periodThrough
+  });
+  return occurrenceContinuityStageResult({
+    audit,
+    gaps,
+    lateGaps,
+    firstGap,
+    eventGaps,
+    periodThrough,
+    progressUnits
+  });
+}
+
+export function occurrenceProgressUnits(plan, { selectedControlIds, periodStart, periodThrough }) {
+  return [
+    ...plan.calendarItems.flatMap((occurrence) => {
+      const completedMemberIds = new Set(occurrence.completedMemberIds || []);
+      const conclusionComplete = occurrence.reconciliationStatus === "reconciled"
+        && ["complete", "complete-with-exceptions", "zero-population"].includes(occurrence.operatingResult);
+      const occurrenceComplete = conclusionComplete || occurrence.legacySchedule && occurrence.status === "complete";
+      const memberUnits = (occurrence.expectedMemberIds || []).map((resourceId) => ({
+        id: `occurrence-${occurrence.occurrenceKey}-member-${resourceId}`,
+        status: occurrenceComplete || completedMemberIds.has(resourceId) ? "complete" : "action",
+        title: `${occurrence.title} member ${resourceId}`
+      }));
+      const membersComplete = memberUnits.every(({ status }) => status === "complete");
+      return [
+        ...memberUnits,
+        {
+          id: `occurrence-${occurrence.occurrenceKey}-reconciliation`,
+          status: occurrenceComplete ? "complete" : membersComplete && occurrence.membershipFinal ? "action" : "blocked",
+          title: `${occurrence.title} reconciliation`
+        }
+      ];
+    }),
+    ...plan.eventRuns
+      .filter((run) => run.status !== "canceled" && run.occurredOn >= periodStart && run.occurredOn <= periodThrough)
+      .flatMap((run) => run.actions)
+      .filter((action) => action.controlIds.some((id) => selectedControlIds.has(id)))
+      .map((action) => ({
+        id: `event-action-${action.actionItemId || action.key}`,
+        status: action.status === "complete" && !action.lateCompletion ? "complete" : "action",
+        title: action.title
+      }))
+  ];
+}
+
+function occurrenceContinuityStageResult({ audit, gaps, lateGaps, firstGap, eventGaps, periodThrough, progressUnits }) {
   return stage(
     "occurrences",
     "Operating Occurrences",
@@ -997,7 +1052,8 @@ function occurrenceContinuityStage(audit, records, model, asOf) {
         commands: firstGap?.actionItemId ? [
           `npx filegrc get ${firstGap.actionItemId} --json`,
           `npx filegrc scaffold finding --title "Late operating occurrence review"`
-        ] : []
+        ] : [],
+        progressUnits
       }
     )]
   );
@@ -1348,12 +1404,33 @@ function populationsStage(audit, records, byId, model) {
   const items = templates.map((template) => {
     const population = populations.find((record) => record.populationKind === template.kind);
     const result = populationResult(population, audit, byId);
+    const preparationComplete = populationPreparationComplete(population, audit);
     return item(
       `population-${template.kind}`,
       result.status,
       template.title,
       result.message || `Use ${template.sourcePrompt} as the starting point, then record the exact authoritative source.`,
-      population || { type: "audit-population" }
+      population || { type: "audit-population" },
+      {
+        progressUnits: population?.status === "not-applicable" ? [
+          {
+            id: `population-${template.kind}-applicability`,
+            status: result.status,
+            title: `${template.title} applicability decision`
+          }
+        ] : [
+          {
+            id: `population-${template.kind}-preparation`,
+            status: preparationComplete ? "complete" : "action",
+            title: `${template.title} preparation`
+          },
+          {
+            id: `population-${template.kind}-conclusion`,
+            status: result.status === "complete" ? "complete" : preparationComplete ? "action" : "blocked",
+            title: `${template.title} reconciliation conclusion`
+          }
+        ]
+      }
     );
   });
   return stage(
@@ -1400,7 +1477,7 @@ function auditorStage(audit, byId, modelVersion) {
   ]);
 }
 
-function populationResult(population, audit, byId) {
+export function populationResult(population, audit, byId) {
   if (!population) return { status: "action", message: "Initialize this population for the engagement." };
   if (!coverageMatches(
     population.coverage,
@@ -1433,6 +1510,7 @@ function populationResult(population, audit, byId) {
     && evidence.type === "evidence"
     && evidence.artifactKind === "population-export"
     && evidence.status === "verified"
+    && (population.ownerIds || []).length > 0
     && (population.sourceComponentId || population.sourceSystemId)
     && (evidence.sourceComponentId || evidence.sourceSystemId) === (population.sourceComponentId || population.sourceSystemId)
     && coverageMatches(
@@ -1459,6 +1537,21 @@ function populationResult(population, audit, byId) {
   };
 }
 
+function populationPreparationComplete(population, audit) {
+  if (!population || !coverageMatches(
+    population.coverage,
+    coverageStart(audit?.coverage),
+    coverageEnd(audit?.coverage)
+  )) return false;
+  if (population.status === "not-applicable") {
+    return !(population.controlIds || []).length && Boolean(String(population.notApplicableReason || "").trim());
+  }
+  return Boolean(
+    (population.ownerIds || []).length
+    && (population.sourceComponentId || population.sourceSystemId)
+  );
+}
+
 function timestampDate(value, timezone) {
   if (!value || !timezone) return null;
   const instant = new Date(value);
@@ -1730,7 +1823,9 @@ function item(id, status, title, message, resource = {}, options = {}) {
     ...(options.commands?.length ? { commands: options.commands } : {}),
     ...(options.affectedActionItemIds?.length ? { affectedActionItemIds: options.affectedActionItemIds } : {}),
     ...(options.affectedEventIds?.length ? { affectedEventIds: options.affectedEventIds } : {}),
-    ...(options.lateCount ? { lateCount: options.lateCount } : {})
+    ...(options.lateCount ? { lateCount: options.lateCount } : {}),
+    ...(options.progressUnits?.length ? { progressUnits: options.progressUnits } : {}),
+    ...(options.progressUnit === false ? { progressUnit: false } : {})
   };
 }
 

package/src/cli.js

@@ -136,6 +136,13 @@ export async function runCli(argv = process.argv.slice(2)) {
     if (result.usedFallbackPort) {
       console.log(`Port ${result.requestedPort} is already in use. Using ${result.address.port} instead.`);
     }
+    if (result.startupSynchronization?.status === "updated") {
+      console.log(`Updated the authoritative branch to ${result.startupSynchronization.shortCommit} before serving.`);
+    } else if (result.startupSynchronization?.status === "blocked") {
+      console.warn(`Remote startup sync is blocked because local and remote history diverged (${result.startupSynchronization.ahead} ahead, ${result.startupSynchronization.behind} behind). Reconcile the branch before relying on this server.`);
+    } else if (result.startupSynchronization?.status === "failed") {
+      console.warn(`Remote startup sync did not complete: ${result.startupSynchronization.message}`);
+    }
     console.log(`filegrc workspace: ${result.url}`);
     console.log(`Data: ${result.root}/data`);
     printGithubStarMessage();

package/src/collection-review.js

@@ -1,11 +1,12 @@
 import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import { modelSupports } from "../model/index.js";
 import {
   collectionRevision,
   collectionRevisionMatches
 } from "./collection-revision.js";
-import { scopedCollectionRecords } from "./collection-scope.js";
-import { applyResourceBatch, INTERNAL_WORKFLOW_CAPABILITIES } from "./files.js";
+import { collectionRecordProposals, retentionScheduleReviewScope, scopedCollectionRecords } from "./collection-scope.js";
+import { applyResourceBatch, applyRetentionScheduleReviewBatch, contentRevision, INTERNAL_WORKFLOW_CAPABILITIES } from "./files.js";
 import { getGitSummary } from "./git.js";
 import { createResourceId } from "./id.js";
 import { loadWorkspace } from "./workspace.js";
@@ -13,6 +14,8 @@ import { resolveProgram } from "./program.js";
 import { currentCalendarDate } from "./time.js";
 import { currentPartyPeople } from "./parties.js";
 import { retentionScheduleApprovalIssues } from "./retention-schedule-approval.js";
+import { markdownEntries } from "./resource-markdown.js";
+import { resolveDataPath } from "./paths.js";
 
 export { collectionRevision };
 
@@ -29,13 +32,21 @@ export function assessCollectionReview(loaded, resourceType, options = {}) {
   const configuration = loaded.model.collectionReviews?.[resourceType];
   if (!configuration) return null;
   const program = resolveProgram(loaded, options.programId);
+  const workspaceWideRetentionReview = resourceType === "retention-schedule-item"
+    && modelSupports(loaded.model, "retention-schedule-approval");
+  const retentionScope = workspaceWideRetentionReview ? retentionScheduleReviewScope(loaded) : null;
   const records = scopedCollectionRecords(loaded, resourceType, program);
-  const reviewEntry = loaded.entries.find(({ record }) => (
+  const reviewEntries = loaded.entries.filter(({ record }) => (
     record.type === "collection-review"
     && record.resourceType === resourceType
     && record.status !== "retired"
-    && (!modelSupports(loaded.model, "program-scope") || (record.scopeResourceIds || []).includes(program.id))
+    && (workspaceWideRetentionReview
+      || !modelSupports(loaded.model, "program-scope")
+      || (record.scopeResourceIds || []).includes(program.id))
   ));
+  const reviewEntry = workspaceWideRetentionReview
+    ? reviewEntries.find(({ record }) => sameIds(record.scopeResourceIds, retentionScope.programIds)) || reviewEntries[0]
+    : reviewEntries[0];
   const review = reviewEntry?.record || null;
   const authoritativeSourceId = review?.decision === "externally-managed"
     ? review.authoritativeComponentId || review.authoritativeSystemId
@@ -71,26 +82,35 @@ export function assessCollectionReview(loaded, resourceType, options = {}) {
       ? assessRetentionScheduleReviewers(loaded, records)
       : null;
   const approvalIssues = resourceType === "retention-schedule-item" && modelSupports(loaded.model, "retention-schedule-approval")
-    ? retentionScheduleApprovalIssues(loaded, program, records, {
-        informationTypesReviewed: assessCollectionReview(loaded, "information-type", options).complete
+    ? retentionScheduleApprovalIssues(loaded, retentionScope, records, {
+        informationTypesReviewed: retentionScope.programIds.every((id) => (
+          assessCollectionReview(loaded, "information-type", { programId: id }).complete
+        )),
+        approvalReview: review?.status === "active" ? review : null
       })
     : [];
+  const recordProposals = collectionRecordProposals(loaded, resourceType, records, program);
+  const incompleteRecordProposals = recordProposals.filter(({ complete: ready }) => !ready);
   const reviewersEligible = !reviewerEligibility || Boolean(
     review?.reviewedByIds?.length
     && review.reviewedByIds.every((id) => reviewerEligibility.eligibleReviewerIds.includes(id))
   );
+  const reviewScopeMatches = !workspaceWideRetentionReview
+    || sameIds(review?.scopeResourceIds, retentionScope.programIds);
   const complete = Boolean(
     review?.status === "active"
     && allowedDecisions.includes(review.decision)
     && revisionMatches
     && temporalReview
+    && reviewScopeMatches
     && reviewersEligible
+    && !incompleteRecordProposals.length
     && !approvalIssues.length
   );
   const stale = Boolean(
     review?.status === "active"
     && review.collectionRevision
-    && !revisionMatches
+    && (!revisionMatches || !reviewScopeMatches)
   );
   return {
     resourceType,
@@ -101,15 +121,19 @@ export function assessCollectionReview(loaded, resourceType, options = {}) {
     reviewRevision: reviewEntry
       ? createHash("sha256").update(reviewEntry.source).digest("hex")
       : null,
+    reviewEntries,
     collectionRevision: currentRevision,
     status: complete ? "current" : stale ? "stale" : "review-required",
     complete,
     ...(reviewerEligibility || {}),
+    ...(recordProposals.length ? { recordProposals, incompleteRecordProposals } : {}),
     ...(approvalIssues.length ? { approvalIssues } : {}),
     message: complete
       ? `${configuration.title} were reviewed on ${review.reviewedOn}.`
       : approvalIssues.length
         ? approvalIssues[0].message
+      : incompleteRecordProposals.length
+        ? `Complete ${incompleteRecordProposals.length} ${configuration.title.toLowerCase()} ${incompleteRecordProposals.length === 1 ? "record proposal" : "record proposals"} before the collection review.`
       : revisionMatches && review?.status === "active" && !reviewersEligible
         ? resourceType === "retention-schedule-item"
           ? "Review the Data Retention Schedule again with a reviewer who does not own its governing document or an included schedule row."
@@ -122,6 +146,11 @@ export function assessCollectionReview(loaded, resourceType, options = {}) {
   };
 }
 
+export function retentionScheduleIsAuthoritative(loaded, program) {
+  return !modelSupports(loaded.model, "retention-schedule-approval")
+    || assessCollectionReview(loaded, "retention-schedule-item", { programId: program?.id }).complete;
+}
+
 export async function scaffoldCollectionReview(input = process.cwd(), options = {}) {
   const loaded = await loadWorkspace(input);
   const program = resolveProgram(loaded, options.programId);
@@ -170,6 +199,9 @@ export async function planCollectionReview(input = process.cwd(), options = {})
   const loaded = await loadWorkspace(input);
   const program = resolveProgram(loaded, options.programId);
   const resourceType = requiredType(loaded, options.resourceType);
+  const workspaceWideRetentionReview = resourceType === "retention-schedule-item"
+    && modelSupports(loaded.model, "retention-schedule-approval");
+  const retentionScope = workspaceWideRetentionReview ? retentionScheduleReviewScope(loaded) : null;
   const assessment = assessCollectionReview(loaded, resourceType, { programId: program.id });
   if (options.expectedCollectionRevision && options.expectedCollectionRevision !== assessment.collectionRevision) {
     throw new Error(`${assessment.configuration.title} changed after it was displayed. Reload and review the current revision before approving it.`);
@@ -178,7 +210,8 @@ export async function planCollectionReview(input = process.cwd(), options = {})
     throw new Error("Data Retention Schedule approval requires the displayed collection revision. Reload or scaffold the current review before approving it.");
   }
   await requireControlReviewReady(loaded, resourceType, program.id);
-  await requireRetentionScheduleReady(loaded, resourceType, program);
+  await requireRetentionScheduleReady(loaded, resourceType, program, retentionScope);
+  requireCollectionRecordProposalsReady(assessment);
   const configuration = assessment.configuration;
   const decision = String(options.decision || "").trim();
   const rationale = String(options.rationale || "").trim();
@@ -251,6 +284,9 @@ export async function planCollectionReview(input = process.cwd(), options = {})
     authoritativeSourceId: decision === "externally-managed" ? authoritativeSourceId : null
   });
   const existing = assessment.review;
+  const existingEntries = workspaceWideRetentionReview
+    ? assessment.reviewEntries
+    : assessment.reviewEntries.filter(({ record }) => record.id === existing?.id);
   const preservesReviewHistory = temporalReviews;
   const record = {
     ...(!existing ? {
@@ -264,7 +300,7 @@ export async function planCollectionReview(input = process.cwd(), options = {})
       type: "collection-review",
       title: `${configuration.title} review`,
       resourceType,
-      scopeResourceIds: [program.id]
+      scopeResourceIds: workspaceWideRetentionReview ? retentionScope.programIds : [program.id]
     } : preservesReviewHistory ? {
       ...existing,
       id: createResourceId(
@@ -281,6 +317,7 @@ export async function planCollectionReview(input = process.cwd(), options = {})
     reviewedOn,
     collectionRevision: currentRevision,
     scopeRevision,
+    ...(workspaceWideRetentionReview ? { scopeResourceIds: retentionScope.programIds } : {}),
     ...(temporalReviews ? {
       coverage: { kind: "as-of", on: reviewedOn },
       knowledgeCutoffAt: now.toISOString(),
@@ -294,34 +331,86 @@ export async function planCollectionReview(input = process.cwd(), options = {})
     delete record.authoritativeSystemId;
     delete record.authoritativeComponentId;
   }
+  const creates = !existing || preservesReviewHistory ? [record] : [];
+  const updates = !existing || preservesReviewHistory ? [] : [record];
+  const expectedRevisions = Object.fromEntries(existingEntries.map((entry) => [
+    entry.record.id,
+    entry.record.id === existing?.id && options.expectedRevision
+      ? options.expectedRevision
+      : createHash("sha256").update(entry.source).digest("hex")
+  ]));
+  if (existingEntries.length && preservesReviewHistory) {
+    for (const entry of existingEntries) {
+      updates.push({
+        ...entry.record,
+        status: "retired",
+        statusTransition: {
+          changedByIds: reviewedByIds,
+          changedOn: reviewedOn,
+          reason: `Superseded by ${record.id}.`
+        }
+      });
+    }
+  }
+  if (resourceType === "retention-schedule-item" && modelSupports(loaded.model, "retention-schedule-approval")) {
+    const scheduleEntry = loaded.entries.find(({ record: candidate }) => (
+      candidate.type === "document"
+      && candidate.documentKind === "schedule"
+      && candidate.workflowScope === "program"
+      && !["superseded", "retired"].includes(candidate.status)
+    ));
+    if (scheduleEntry && ["draft", "approved", "active"].includes(scheduleEntry.record.status)) {
+      const currentContentRevisions = await contentRevisions(loaded, scheduleEntry.record);
+      const approvedSchedule = {
+        ...scheduleEntry.record,
+        status: "approved",
+        approverIds: reviewedByIds,
+        approvedOn: reviewedOn,
+        approvedContentRevisions: currentContentRevisions
+      };
+      for (const field of [
+        "activationBasis",
+        "activatedByIds",
+        "activatedOn",
+        "activatedContentRevisions",
+        "effectiveOn",
+        "statusTransition"
+      ]) delete approvedSchedule[field];
+      updates.push(approvedSchedule);
+      expectedRevisions[scheduleEntry.record.id] = scheduleEntry.revision;
+    }
+  }
   return {
     operation: "collection-review",
     resourceType,
     assessment,
     changes: {
-      ...(!existing || preservesReviewHistory ? { create: [record] } : { update: [record] }),
-      ...(existing && preservesReviewHistory ? {
-        update: [{
-          ...existing,
-          status: "retired",
-          statusTransition: {
-            changedByIds: reviewedByIds,
-            changedOn: reviewedOn,
-            reason: `Superseded by ${record.id}.`
-          }
-        }]
-      } : {}),
-      ...(existing ? {
-        expectedRevisions: {
-          [existing.id]: options.expectedRevision || assessment.reviewRevision
-        }
-      } : {}),
+      ...(creates.length ? { create: creates } : {}),
+      ...(updates.length ? { update: updates } : {}),
+      ...(Object.keys(expectedRevisions).length ? { expectedRevisions } : {}),
       validateWholeWorkspace: true,
       workflowCapability: INTERNAL_WORKFLOW_CAPABILITIES.collectionReviewReassessment
     }
   };
 }
 
+function requireCollectionRecordProposalsReady(assessment) {
+  const incomplete = assessment.incompleteRecordProposals || [];
+  if (!incomplete.length) return;
+  throw new Error(
+    `Complete every ${assessment.configuration.title.toLowerCase()} record proposal before the collection review. Remaining: ${incomplete.map(({ title }) => title).join(", ")}.`
+  );
+}
+
+async function contentRevisions(loaded, record) {
+  const revisions = {};
+  for (const markdown of markdownEntries(loaded.model, record)) {
+    const source = await readFile(resolveDataPath(loaded.root, markdown.path), "utf8");
+    revisions[markdown.path] = contentRevision(source);
+  }
+  return revisions;
+}
+
 async function requireControlReviewReady(loaded, resourceType, programId) {
   if (resourceType !== "control") return;
   const { assessProgramReadiness } = await import("./program-readiness.js");
@@ -339,11 +428,13 @@ async function requireControlReviewReady(loaded, resourceType, programId) {
   }
 }
 
-async function requireRetentionScheduleReady(loaded, resourceType, program) {
+async function requireRetentionScheduleReady(loaded, resourceType, program, retentionScope) {
   if (resourceType !== "retention-schedule-item" || !modelSupports(loaded.model, "retention-schedule-approval")) return;
   const rows = scopedCollectionRecords(loaded, resourceType, program);
-  const approvalIssues = retentionScheduleApprovalIssues(loaded, program, rows, {
-    informationTypesReviewed: assessCollectionReview(loaded, "information-type", { programId: program.id }).complete
+  const approvalIssues = retentionScheduleApprovalIssues(loaded, retentionScope || program, rows, {
+    informationTypesReviewed: (retentionScope?.programIds || [program.id]).every((id) => (
+      assessCollectionReview(loaded, "information-type", { programId: id }).complete
+    ))
   });
   if (approvalIssues.length) throw new Error(approvalIssues[0].message);
 }
@@ -388,7 +479,7 @@ function assessRetentionScheduleReviewers(loaded, rows) {
   };
 }
 
-function sameIds(left, right) {
+function sameIds(left = [], right = []) {
   return JSON.stringify([...left].sort()) === JSON.stringify([...right].sort());
 }
 
@@ -397,7 +488,9 @@ export async function applyCollectionReview(input = process.cwd(), options = {})
     throw new Error("Preview the collection review and confirm the write.");
   }
   const plan = await planCollectionReview(input, options);
-  const result = await applyResourceBatch(input, plan.changes);
+  const result = plan.resourceType === "retention-schedule-item"
+    ? await applyRetentionScheduleReviewBatch(input, plan.changes)
+    : await applyResourceBatch(input, plan.changes);
   const loaded = await loadWorkspace(input);
   return {
     ...plan,

package/src/collection-revision.js

@@ -30,7 +30,12 @@ export function collectionRevisionMatches(loaded, resourceType, storedRevision,
 }
 
 function calculateCollectionRevision(loaded, resourceType, options, legacy) {
-  const program = Object.hasOwn(options, "program")
+  const workspaceWideRetentionReview = resourceType === "retention-schedule-item"
+    && modelSupports(loaded.model, "retention-schedule-approval")
+    && !legacy;
+  const program = workspaceWideRetentionReview
+    ? null
+    : Object.hasOwn(options, "program")
     ? options.program
     : resolveProgram(loaded, options.programId);
   const inputs = new Map(collectionRevisionInputs(loaded, resourceType, program, { legacy })