filegrc 0.16.17 → 0.16.19

package/model/v11.json

@@ -2603,7 +2603,7 @@
         "cadence": "Create before relying on a promise, review during audit scoping, and supersede it when the service or agreement changes.",
         "reviewPoints": [
           "Confirm the statement reflects a real customer promise, service requirement, or approved business objective that applies to the current scope.",
-          "Confirm which parts of the service the promise or objective affects.",
+          "Confirm which parts of the service the promise or objective affects. When a linked Policy or Document has independent sections, name the exact governing Markdown heading in sourceSectionHeadings before reviewing downstream mappings.",
           "Use \"External\", \"Zero Population\", or \"Not Applicable\" only when it is true for the current scope."
         ],
         "sourceResourceIds": [
@@ -2657,6 +2657,12 @@
             "requirement"
           ]
         },
+        "sourceSectionHeadings": {
+          "type": "object",
+          "objectType": "string-map",
+          "label": "Reviewed source sections",
+          "description": "Map a source Policy or Document ID to one exact Markdown heading when the Commitment comes from that section."
+        },
         "requirementIds": {
           "type": "array",
           "items": "id",
@@ -2731,6 +2737,7 @@
       "formFields": [
         "systemIds",
         "sourceResourceIds",
+        "sourceSectionHeadings",
         "requirementIds",
         "controlIds",
         "applicabilityReview",
@@ -7706,6 +7713,7 @@
         "reviewPoints": [
           "Confirm the Information Types and operational scope covered by this item.",
           "Confirm the cutoff, retention period, and disposition action from management sources.",
+          "When a linked Policy or Document has independent sections, set sourceSectionHeadings to the exact governing Markdown heading. Keep a whole-source binding when the entire source governs the row.",
           "Keep the item planned until the owner completes every organization-specific value and binds the current source revisions."
         ],
         "sourceResourceIds": [
@@ -7779,6 +7787,12 @@
           ],
           "label": "Authority and source records"
         },
+        "sourceSectionHeadings": {
+          "type": "object",
+          "objectType": "string-map",
+          "label": "Reviewed source sections",
+          "description": "Map a source Policy or Document ID to one exact Markdown heading when only that section governs this decision. Omit the ID when the complete source governs it."
+        },
         "cutoff": {
           "type": "object",
           "objectType": "retention-cutoff",
@@ -7882,6 +7896,7 @@
         "scopeResourceIds",
         "scheduleDocumentId",
         "sourceResourceIds",
+        "sourceSectionHeadings",
         "cutoff",
         "retentionPeriod",
         "dispositionAction",

package/package.json

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

package/src/agent.js

@@ -122,13 +122,15 @@ export function buildAgentGuide(loaded, type, options = {}) {
     oneOf: definition.oneOf ?? [],
     markdown,
     workflow: [
-      "Inspect existing records and relation candidates before writing.",
+      "Inspect the recommended action, existing records, relationships, source Markdown, and available evidence. Do the research, drafting, record edits, and validation you can do yourself.",
       definition.singleton
         ? "Open the existing singleton record and update only gaps supported by facts from an authoritative source."
         : "Reuse and update a suitable existing record. Create a scaffold only when no record covers the work, then replace every null value and empty required array with facts from an authoritative source.",
       recommendedMarkdown.length
         ? "Keep model fields in JSON and use the recommended Markdown companion for the detailed work, decisions, results, exceptions, and follow-up that apply to this record."
         : "Keep the current facts and lifecycle state in JSON. Add optional Record Markdown only when the model fields cannot explain the record clearly.",
+      "If a material fact, external action, approval, or management decision is still missing, ask the user one specific question. State what you inspected, the exact missing input, and what it unlocks. Do not hand off FileGRC commands, routine record entry, or a vague request to confirm. Continue the workflow after the answer without asking for another handoff.",
+      ...(type === "control" ? ["Separate implementation from operation: document the working configuration, scope, owner, procedure, source, and enabled rules when its operation pattern needs them before marking Implemented. Record dated operating work and evidence only after a real cycle or event occurs; a ready schedule is not proof of operation."] : []),
       ...(type === "program" && modelSupports(loaded.model, "program-scope")
         ? ["Review Requirement applicability with npx filegrc review-applicability --type requirement --scaffold, then preview and apply the reviewed decisions as one validated batch."]
         : []),

package/src/cli.js

@@ -586,12 +586,14 @@ export async function runCli(argv = process.argv.slice(2)) {
         ? [...new Set([...(record.sourceResourceIds || []), ...(record.targetResourceIds || [])])]
         : null;
     if (!dependencyIds) throw new Error("Review bindings are available for Retention Schedule records and Requirement Mappings.");
-    const revisions = await resourceReviewRevisions(loaded, dependencyIds);
+    const revisions = await resourceReviewRevisions(loaded, dependencyIds, "legacy", record);
+    const missingSectionIds = dependencyIds.filter((id) => Object.hasOwn(record.sourceSectionHeadings || {}, id) && !revisions.has(id));
     const result = {
       resource: { type: record.type, id: record.id, title: record.title },
       dependencyIds,
       reviewedSourceRevisions: Object.fromEntries(revisions),
-      missingResourceIds: dependencyIds.filter((id) => !revisions.has(id))
+      missingResourceIds: dependencyIds.filter((id) => !revisions.has(id) && !missingSectionIds.includes(id)),
+      ...(missingSectionIds.length ? { missingSectionIds } : {})
     };
     if (flags.json) console.log(JSON.stringify(result, null, 2));
     else {
@@ -1743,7 +1745,7 @@ function agentOverview(model) {
     commit: "git diff --check && git diff && git add <reviewed-paths> && git commit -m <reason>"
   };
   return {
-    rule: "Treat data/ as the source of truth. Run guide before creating an unfamiliar type, validate after every write, review the Git diff, then commit a focused change.",
+    rule: "Treat data/ as the source of truth. Inspect existing records and sources, then do the research, edits, and validation you can do. Ask the user only for a specific material fact, external action, approval, or decision you cannot establish; explain what it unlocks and continue after the answer. Run guide before creating an unfamiliar type, validate every write, review the Git diff, and commit a focused change.",
     programPath: buildAgentProgramPath(model),
     actions: Object.fromEntries(Object.entries(commands).map(([name, command]) => [
       name,

package/src/collection-revision.js

@@ -30,6 +30,10 @@ export function collectionRevisionMatches(loaded, resourceType, storedRevision,
   // Accept both the pre-0.16 scope: input and the digest-only input used by
   // 0.16.0, as well as the older collection basis from 0.9.1.
   if (revisionsMatch("collection", storedRevision, currentRevision)) return true;
+  if (resourceType === "retention-schedule-item" && modelSupports(loaded.model, "retention-schedule-approval")
+    && revisionsMatch("collection", storedRevision, calculateCollectionRevision(
+      loaded, resourceType, { ...options, legacyRetentionSourceBasis: true }, false
+    ))) return true;
   const allowOlderBasis = resourceType !== "retention-schedule-item"
     || !modelSupports(loaded.model, "retention-schedule-approval");
   for (const olderBasis of [false, true]) {
@@ -152,13 +156,17 @@ function historicallyEquivalentCollection(loaded, resourceType, stored, options,
     // Require the complete reviewed basis to be unchanged under the current
     // semantic calculation before accepting an older byte-sensitive digest.
     if (!revisionsMatch("collection", current, collectionRevision(snapshot, resourceType, historicalOptions))) continue;
-    for (const legacy of [false, true]) {
-      for (const scopeHashInput of ["legacy", "digest"]) {
-        for (const scopeFactsInput of ["legacy", "source"]) {
-          if (revisionsMatch("collection", stored, calculateCollectionRevision(
-            snapshot, resourceType, { ...historicalOptions, historicalReviewMetadata: true },
-            legacy, scopeHashInput, scopeFactsInput
-          ))) return true;
+    for (const legacyRetentionSourceBasis of resourceType === "retention-schedule-item" ? [false, true] : [false]) {
+      for (const historicalReviewMetadata of legacyRetentionSourceBasis ? [false] : [true]) {
+        for (const legacy of [false, true]) {
+          for (const scopeHashInput of ["legacy", "digest"]) {
+            for (const scopeFactsInput of ["legacy", "source"]) {
+              if (revisionsMatch("collection", stored, calculateCollectionRevision(
+                snapshot, resourceType, { ...historicalOptions, historicalReviewMetadata, legacyRetentionSourceBasis },
+                legacy, scopeHashInput, scopeFactsInput
+              ))) return true;
+            }
+          }
         }
       }
     }
@@ -175,7 +183,12 @@ function calculateCollectionRevision(loaded, resourceType, options, legacy, scop
     : Object.hasOwn(options, "program")
     ? options.program
     : resolveProgram(loaded, options.programId);
-  const inputs = new Map(collectionRevisionInputs(loaded, resourceType, program, { legacy, historicalReviewMetadata: options.historicalReviewMetadata })
+  const inputs = new Map(collectionRevisionInputs(loaded, resourceType, program, {
+    legacy,
+    historicalReviewMetadata: options.historicalReviewMetadata,
+    historicalCommit: options.historicalCommit,
+    legacyRetentionSourceBasis: options.legacyRetentionSourceBasis
+  })
     .map((input) => [input.record.id, input]));
   const authoritativeSource = loaded.resources.find(({ id }) => id === options.authoritativeSourceId);
   if (authoritativeSource) {

package/src/collection-scope.js

@@ -1,6 +1,6 @@
 import { modelSupports } from "../model/index.js";
 import { programComponents, selectedRequirementIds } from "./program.js";
-import { retentionReviewResourceIds, retentionUses } from "./retention.js";
+import { resourceReviewRevisionsSync, retentionReviewResourceIds, retentionUses } from "./retention.js";
 import { documentIsAuditSpecific } from "./program-lifecycle.js";
 
 export function scopedCollectionRecords(loaded, resourceType, program) {
@@ -210,6 +210,8 @@ export function collectionRevisionInputs(loaded, resourceType, program, options
   const byId = new Map(loaded.resources.map((record) => [record.id, record]));
   const records = new Map(reviewed.map((record) => [record.id, record]));
   const reviewedIds = new Set(records.keys());
+  const scheduleDocumentIds = new Set(resourceType === "retention-schedule-item"
+    ? reviewed.map((record) => record.scheduleDocumentId).filter(Boolean) : []);
   const addIds = (ids) => {
     for (const id of ids || []) {
       const record = byId.get(id);
@@ -363,7 +365,7 @@ export function collectionRevisionInputs(loaded, resourceType, program, options
     record,
     value: reviewedIds.has(record.id)
       ? resourceType === "retention-schedule-item" && modelSupports(loaded.model, "retention-schedule-approval")
-        ? retentionScheduleRowProposalValue(record, options.historicalReviewMetadata)
+        ? retentionScheduleRowProposalValue(record, loaded, options)
         : options.historicalReviewMetadata ? record : substantiveRevisionValue(record)
       : resourceType === "retention-schedule-item"
         && modelSupports(loaded.model, "retention-schedule-approval")
@@ -371,19 +373,25 @@ export function collectionRevisionInputs(loaded, resourceType, program, options
           ? retentionScheduleDocumentProposalValue(record)
           : options.historicalReviewMetadata
             ? dependencyRevisionValue(resourceType, record, legacy, true, currentModel)
-            : substantiveRevisionValue(dependencyRevisionValue(resourceType, record, legacy, false, currentModel)),
+            : substantiveRevisionValue(dependencyRevisionValue(resourceType, record, legacy, false, currentModel, scheduleDocumentIds, options.legacyRetentionSourceBasis)),
     includeContent: legacy
       || reviewedIds.has(record.id)
-      || dependencyContentAffectsRevision(resourceType, record.type, options.historicalReviewMetadata, currentModel)
+      || dependencyContentAffectsRevision(resourceType, record, options.historicalReviewMetadata, currentModel, scheduleDocumentIds, options.legacyRetentionSourceBasis)
   }));
 }
 
-function retentionScheduleRowProposalValue(record, historicalReviewMetadata = false) {
-  return Object.fromEntries(Object.entries(record).filter(([field]) => ![
+function retentionScheduleRowProposalValue(record, loaded, options = {}) {
+  const value = Object.fromEntries(Object.entries(record).filter(([field]) => ![
     "approvedByIds",
     "approvedOn",
-    ...(historicalReviewMetadata ? [] : ["reviewedSourceRevisions", "tags", "statusTransition"])
+    ...(options.historicalReviewMetadata ? [] : ["reviewedSourceRevisions", "tags", "statusTransition"])
   ].includes(field)));
+  if (!options.historicalReviewMetadata && !options.legacyRetentionSourceBasis) {
+    value.sourceDecisionRevisions = Object.fromEntries(resourceReviewRevisionsSync(
+      loaded, record.sourceResourceIds || [], "legacy", false, options.historicalCommit || null, record
+    ));
+  }
+  return value;
 }
 
 function retentionScheduleDocumentProposalValue(record) {
@@ -533,7 +541,7 @@ const dependencyFields = {
     obligation: ["id", "type", "status", "activityType", "scheduleMode", "ownerIds", "activeRuleId", "policyIds", "controlIds", "ruleIds"],
     "source-coverage": ["id", "type", "status", "sourceFamilyId", "coverageKind", "scopeResourceIds", "excludedPopulation", "retrieverIds", "collectionCadence", "retentionScheduleItemIds", "reconciliationMethod", "validFrom", "validThrough", "applicabilityReview", "readinessTestEvidenceIds", "ownerIds", "componentId"],
     evidence: ["id", "type", "status", "artifactKind", "readinessTest", "retrievalResult", "accessConfirmed", "coveredSourceFamilyIds", "sourceComponentId", "componentIds", "systemIds", "collectedOn", "collectorIds", "verifierIds", "verifiedOn"],
-    "retention-schedule-item": ["id", "type", "status", "description", "informationTypeIds", "scopeResourceIds", "scheduleDocumentId", "sourceResourceIds", "ownerIds", "approvedByIds", "approvedOn", "reviewedSourceRevisions", "cutoff", "retentionPeriod", "dispositionAction", "dispositionInstructions"],
+    "retention-schedule-item": ["id", "type", "status", "description", "informationTypeIds", "scopeResourceIds", "scheduleDocumentId", "sourceResourceIds", "sourceSectionHeadings", "ownerIds", "approvedByIds", "approvedOn", "reviewedSourceRevisions", "cutoff", "retentionPeriod", "dispositionAction", "dispositionInstructions"],
     document: ["id", "type", "documentKind", "workflowScope", "ownerIds", "approverIds", "approvedOn", "approvedContentRevisions", "controlIds"],
     policy: ["id", "type", "programRole", "ownerIds", "approverIds", "approvedOn", "approvedContentRevisions", "relatedDocumentIds", "controlIds"],
     training: ["id", "type", "ownerIds", "approverIds", "approvedOn", "approvedContentRevisions", "controlIds"],
@@ -597,7 +605,12 @@ const dependencyContentTypes = {
   "complementary-control": new Set(["system", "document", "component"])
 };
 
-function dependencyRevisionValue(resourceType, record, legacy, historicalReviewMetadata = false, currentModel = false) {
+function dependencyRevisionValue(resourceType, record, legacy, historicalReviewMetadata = false, currentModel = false, scheduleDocumentIds = new Set(), legacyRetentionSourceBasis = false) {
+  if (resourceType === "retention-schedule-item" && currentModel && !historicalReviewMetadata && !legacyRetentionSourceBasis
+    && (["policy", "requirement", "commitment", "control"].includes(record.type)
+      || record.type === "document" && record.documentKind !== "schedule" && !scheduleDocumentIds.has(record.id))) {
+    return { id: record.id, type: record.type };
+  }
   const controlDecision = currentModel && !historicalReviewMetadata && record.type === "control"
     && ["retention-schedule-item", "complementary-control"].includes(resourceType);
   const fields = controlDecision
@@ -616,9 +629,12 @@ function dependencyRevisionValue(resourceType, record, legacy, historicalReviewM
   return value;
 }
 
-function dependencyContentAffectsRevision(resourceType, dependencyType, historicalReviewMetadata = false, currentModel = false) {
-  return ((!currentModel || historicalReviewMetadata) && resourceType === "complementary-control" && dependencyType === "control")
-    || dependencyContentTypes[resourceType]?.has(dependencyType) || false;
+function dependencyContentAffectsRevision(resourceType, dependency, historicalReviewMetadata = false, currentModel = false, scheduleDocumentIds = new Set(), legacyRetentionSourceBasis = false) {
+  if (resourceType === "retention-schedule-item" && currentModel && !historicalReviewMetadata && !legacyRetentionSourceBasis
+    && (dependency.type === "policy" || dependency.type === "document"
+      && dependency.documentKind !== "schedule" && !scheduleDocumentIds.has(dependency.id))) return false;
+  return ((!currentModel || historicalReviewMetadata) && resourceType === "complementary-control" && dependency.type === "control")
+    || dependencyContentTypes[resourceType]?.has(dependency.type) || false;
 }
 
 function sorted(values) {

package/src/program-amendment.js

@@ -128,7 +128,7 @@ export async function planProgramAmendment(input, options = {}) {
   const retention = related.filter((record) => (
     record.type === "retention-schedule-item"
     && record.status === "active"
-    && reviewBindingsDiffer(retentionReviewResourceIds(record, loaded), record.reviewedSourceRevisions, currentReviewRevisions, loaded)
+    && reviewBindingsDiffer(retentionReviewResourceIds(record, loaded), record.reviewedSourceRevisions, currentReviewRevisions, loaded, record)
   ));
   if (retention.length) {
     missing.push({
@@ -161,10 +161,10 @@ export async function planProgramAmendment(input, options = {}) {
   };
 }
 
-function reviewBindingsDiffer(expectedIds, reviewed = {}, current, loaded) {
+function reviewBindingsDiffer(expectedIds, reviewed = {}, current, loaded, reviewer = null) {
   const expected = new Set(expectedIds);
   if (Object.keys(reviewed).length !== expected.size) return true;
-  return [...expected].some((id) => !resourceReviewRevisionMatches(loaded, current, id, reviewed[id]));
+  return [...expected].some((id) => !resourceReviewRevisionMatches(loaded, current, id, reviewed[id], reviewer));
 }
 
 export async function assessProgramAmendmentReadiness(loaded) {

package/src/program-path.js

@@ -4,11 +4,11 @@ export const RESOURCE_INSTRUCTIONS = {
   program: "Set the Program goal, owners, Systems, Frameworks, criteria decisions, and risk method.",
   person: "Record the person’s actual job title and current status.",
   appointment: "Assign a named authority to one Person with its start date and scope.",
-  team: "Confirm the Team’s members and chair.",
+  team: "Use the current Person and Appointment records to set the Team’s members and chair; ask who holds a role only when those sources cannot establish it.",
   system: "Define the service boundary, exclusions, owners, and information it handles.",
   component: "Record a material service or evidence source and its role in each linked System.",
   vendor: "Record each material external provider and the Components it supplies.",
-  classification: "Confirm the handling categories and apply them to information and evidence.",
+  classification: "Use current Policy content and recorded information needs to propose handling categories, then apply the management decision to information and evidence. Ask about any category those sources do not settle.",
   "information-type": "Name a stable category of information, set its default Classification, and link its uses.",
   framework: "Select the criteria Framework and version used by the Program.",
   requirement: "Review whether this criterion applies to the Program and record the decision and rationale.",
@@ -22,7 +22,7 @@ export const RESOURCE_INSTRUCTIONS = {
   evidence: "Record a real artifact or approved reference, link its source and supported work, then have another person verify it.",
   "risk-assessment": "Assess the in-scope service, record conclusions, and obtain an independent review.",
   risk: "Name the threat and impact, assign an owner, rate the risk, and record its response.",
-  obligation: "Confirm the owner, cadence or trigger, deadline, and proof, then enable the rule when its Control is ready.",
+  obligation: "Read the linked Policy and Control, fill the owner, cadence or trigger, deadline, and proof from those sources, then enable the rule when its Control is ready. Ask only for an unresolved management choice.",
   "retention-schedule-item": "Set the Information Types, scope, cutoff, period, disposition, and sources for one retention rule.",
   "obligation-event": "Record the actual event date and subject, then complete its linked Work Queue actions.",
   "policy-review": "Record the review date, reviewer, decision, and any required follow-up.",
@@ -101,11 +101,11 @@ export const RESOURCE_OUTPUTS = {
 };
 
 export const RESOURCE_PAGE_SUMMARIES = {
-  person: "Confirm who works on the program.",
+  person: "Use current people already recorded; ask for a missing person's identity or role only when needed.",
   appointment: "Assign named authority.",
-  team: "Confirm shared owners and members.",
+  team: "Set shared owners and members from current People and Appointments.",
   program: "Choose the goal, scope, criteria, controls, owners, and risk method.",
-  framework: "Confirm the SOC 2 framework.",
+  framework: "Select the applicable SOC 2 framework and version from the installed catalog.",
   requirement: "Decide which SOC 2 criteria apply.",
   commitment: "Record customer promises that affect scope.",
   "requirement-mapping": "Review how supplemental promises relate to Requirements and Controls.",
@@ -134,8 +134,8 @@ export const PROGRAM_PATH = [
     description: "Ownership, criteria, and service boundary",
     summary: "A reviewed Program scope with owners, criteria, Systems, and material providers.",
     sections: [
-      { id: "ownership", title: "Program Ownership", description: "Confirm who owns the program, plus the normal security reporting channel and its fallback.", steps: ["Confirm the program lead, policy owner, independent reviewer, and oversight team.", "Replace the reporting-channel placeholders with real normal and fallback routes, then commit the proposal."], types: ["person", "appointment", "team", "reporting-route-set"], defaultOpen: true },
-      { id: "criteria", title: "Program and Criteria", description: "Define the Program, confirm its Frameworks, record Program-scoped Requirement applicability, and connect customer commitments that shape the System or Control design.", steps: ["Set the Program goal, owners, risk method, and tentative timing.", "Review each selected criterion for this service and record its applicability decision.", "Replace the starter Commitment prompt with the real promise; add only needed supplemental mappings."], types: ["program", "framework", "requirement", "commitment", "requirement-mapping"], defaultOpen: true },
+      { id: "ownership", title: "Program Ownership", description: "Assign program owners and set the normal security reporting channel and its fallback.", steps: ["Inspect current People and Appointments, then assign the program lead, policy owner, independent reviewer, and oversight team. Ask only for missing assignments.", "Use the actual normal and fallback routes to replace reporting-channel placeholders, then commit the proposal."], types: ["person", "appointment", "team", "reporting-route-set"], defaultOpen: true },
+      { id: "criteria", title: "Program and Criteria", description: "Define the Program, select its Frameworks, record Program-scoped Requirement applicability, and connect customer commitments that shape the System or Control design.", steps: ["Set the Program goal, owners, risk method, and tentative timing from current records; ask for unresolved management choices.", "Compare each selected criterion with the service scope and record its applicability decision.", "Replace the starter Commitment prompt with the actual promise; add only needed supplemental mappings."], types: ["program", "framework", "requirement", "commitment", "requirement-mapping"], defaultOpen: true },
       { id: "boundary", title: "System Boundary", description: "Start with the bounded System. Add Components that materially deliver the service, support Controls, produce authoritative Evidence, or support relevant operations. Keep Vendor relationships and specific Assets separate.", steps: ["Define the service and exclusions in a bounded System selected by the Program.", "Add material Components and Vendors with their actual System relationships.", "Record the Information Types and Classifications the service uses."], types: ["system", "component", "vendor", "classification", "information-type"], defaultOpen: false }
     ],
     resourceTypes: ["person", "appointment", "team", "reporting-route-set", "program", "framework", "requirement", "commitment", "requirement-mapping", "system", "component", "vendor", "classification", "information-type"],
@@ -160,7 +160,7 @@ export const PROGRAM_PATH = [
     description: "Approve governed content and retention decisions",
     summary: "Approved Policies, program Documents, Training content, and retention decisions.",
     sections: [
-      { id: "policy-content", title: "Policies", description: "Approve the program's governing content.", instructions: "Open each Policy, program Document, and Training record. Replace placeholders, confirm the owner and intended values, then have a separate person approve the exact Markdown revision.", output: "Approved content bound to the reviewed revisions.", steps: ["Replace placeholders with the company's real rules, plans, and training material.", "Confirm the owner, separate approver, linked Controls, audience, and intended values.", "Record the independent approval and date against each exact Markdown revision."], types: [], relatedLinks: [{ type: "policy", label: "Policies", href: "#/policies" }], defaultOpen: true },
+      { id: "policy-content", title: "Policies", description: "Approve the program's governing content.", instructions: "Open each Policy, program Document, and Training record. Draft from current approved decisions, replace placeholders, and resolve only material choices with management. A separate person then approves the exact Markdown revision.", output: "Approved content bound to the reviewed revisions.", steps: ["Draft the company's real rules, plans, and training material from current scope and approved decisions.", "Resolve missing owner, separate approver, Control links, audience, or intended values from authoritative records; ask only when a material decision remains.", "Have the independent approver review the exact Markdown revision and record their actual decision and date."], types: [], relatedLinks: [{ type: "policy", label: "Policies", href: "#/policies" }], defaultOpen: true },
       { id: "retention", title: "Data Retention Schedule", description: "Approve the schedule document and its completed rows together.", steps: ["Review the governing schedule and any legal hold or exception rules.", "Complete a row for each distinct information use, cutoff, retention period, and disposition.", "Have a separate reviewer approve the complete document and row set."], types: [], utility: "retention-schedule", defaultOpen: true }
     ],
     resourceTypes: [],
@@ -184,7 +184,7 @@ export const PROGRAM_PATH = [
     description: "Implement and prepare to operate",
     summary: "Implemented Controls with ready evidence sources and enabled work schedules.",
     sections: [
-      { id: "controls", title: "Controls", description: "Put each selected Control into use and record what is actually in place.", steps: ["Open each Control for its specific setup action and current missing checks.", "Configure the activity and record its procedure, Systems, owner, and evidence sources.", "Mark it Implemented with its real start date after its sources and schedules are ready."], types: ["control"], defaultOpen: true },
+      { id: "controls", title: "Controls", description: "Put each selected Control into use and record its working design. Dated operating proof follows when work occurs.", steps: ["Open each Control, linked records, and current missing checks; do the setup that can be established from those sources.", "Configure the activity and record its procedure, Systems, owner, evidence sources, and any work rules its operation pattern requires.", "Mark it Implemented with its real start date when it works. Record later cycles and events separately with dated proof."], types: ["control"], defaultOpen: true },
       { id: "complementary-controls", title: "Complementary Controls", description: "Record customer or provider responsibilities that form part of the implementation boundary, or confirm there are none.", steps: ["Identify any customer or carved-out provider action an in-scope Control depends on.", "Record each dependency, or confirm that the current scope has none."], types: ["complementary-control"], defaultOpen: true },
       { id: "evidence-sources", title: "Evidence Sources", description: "Check that every Control points to an authoritative source that can produce its expected evidence.", steps: ["For each Control family, link an active Component with the required source kind, access owners, and retrieval instructions."], types: [], utility: "evidence-sources", defaultOpen: true },
       { id: "obligations", title: "Obligations", description: "Configure the calendar and event schedules that operate the Controls.", steps: ["Check the owner, trigger or cadence, due window, and required proof for each Obligation.", "Enable the rules that will run the implemented Controls."], types: ["obligation"], defaultOpen: true }

package/src/program-readiness.js

@@ -217,7 +217,7 @@ export async function assessProgramReadiness(input, options = {}) {
       ? item
       : { ...item, status: "blocked", message: `Complete the Control collection review before activation. ${item.message}` };
   }));
-  controlStage.description = `Each implemented Control needs an owner, actual procedure, scope, operation pattern, mappings, an implementation date, enabled Obligations, and complete authoritative source ${modelSupports(loaded.model, "component-sources") ? "Components" : "Systems"}. When implementation is ready, perform one review of the implemented Control collection. Management then activates the unchanged approved program content as the Step 3 cutover.`;
+  controlStage.description = `Each implemented Control needs an owner, actual procedure, scope, operation pattern, mappings, an implementation date, enabled Obligations for scheduled or event work, and complete authoritative source ${modelSupports(loaded.model, "component-sources") ? "Components" : "Systems"}. When implementation is ready, perform one review of the implemented Control collection. Management then activates the unchanged approved program content as the Step 3 cutover.`;
   const scopeReadinessStage = scopeStage(
       program,
       scope,
@@ -596,7 +596,7 @@ function scopeStage(workspace, scope, records, byId, model, collectionReviews =
   items.push(item(
     "criteria",
     criteriaComplete ? "complete" : "action",
-    "Confirm Trust Services criteria, Description Criteria, and Controls",
+    "Resolve criteria decisions and Control coverage",
     criteriaComplete
       ? `${selectedTrustServicesRequirements.length} applicable Trust Services criteria, ${selectedDescriptionRequirements.length} SOC 2 Description Criteria, and ${scope.controls.length} Controls are in scope. Every applicable Trust Services criterion has at least one selected Control; Description Criteria govern the system description and do not map to Controls.`
       : missingRequiredSecurityReferences.length || missingRequiredDescriptionReferences.length
@@ -992,7 +992,7 @@ function programOwnershipItem(records, byId) {
   return item(
     "program-ownership",
     complete ? "complete" : "action",
-    "Confirm program owners and oversight",
+    "Assign program owners and oversight",
     complete
       ? `${currentOwners.size} current ${currentOwners.size === 1 ? "person owns" : "people own"} the program records.${oversight ? " Security and Risk Oversight has a separate current chair." : ""}`
       : detail.join(" "),
@@ -1619,7 +1619,7 @@ function policyActivationItem(assessment) {
     [assessment.unresolvedExceptionIds.length, "unresolved Exceptions"]
   ].filter(([count]) => count).map(([count, label]) => `${count} ${label}`);
   const message = assessment.state === "active-and-operating"
-    ? `Active and effective ${assessment.effectiveOn}; all ${assessment.linkedControlIds.length} linked Controls are implemented with Components, evidence sources, and enabled Obligations.`
+    ? `Active and effective ${assessment.effectiveOn}; all ${assessment.linkedControlIds.length} linked Controls are implemented with Components, evidence sources, and enabled Obligations where scheduled or event work requires them.`
     : assessment.state === "ready-to-activate"
       ? "Implementation checks are complete. Include this approved Policy in the Step 3 cutover when you are ready for it to take effect."
       : `${assessment.label}: ${counts.join(", ") || assessment.timingWarnings.join(" ")}. ${assessment.activationWarning || ""}`.trim();
@@ -2128,7 +2128,7 @@ const starterControlChecks = {
   "control-monitoring-remediation": "Schedule the first Control review. Name who will inspect incidents, tests, Exceptions, overdue work, and follow-up closure when those records exist.",
   "control-access-authorization": "Open access lists for in-scope Systems and Vendor tools. Check that accounts use unique identities and only needed permissions, and new grants require a business reason and approval.",
   "control-strong-authentication": "Open the System and Vendor lists. For each tool used for production, source code, email, identity, or sensitive data, check MFA, unique accounts, default credentials, and admin roles.",
-  "control-access-review-offboarding": "Confirm access lists can be exported from key Systems and Vendor tools. Assign the first access review and the owner who will remove access when a departure occurs.",
+  "control-access-review-offboarding": "Check whether key Systems and Vendor tools can export access lists. Set the first access review and name who removes access after a departure.",
   "control-physical-workspace-security": "Walk through actual work areas and visitor access. Check who can enter nonpublic spaces and how devices, papers, screens, and conversations are protected.",
   "control-data-classification-inventory": "List important data stores in Systems and Vendor tools. Check each has an owner, classification, approved purpose, and recorded location.",
   "control-encryption-transmission": "For Systems, Vendor tools, and devices holding Confidential or Restricted data, check encryption at rest and in transit and who can manage the keys.",
@@ -2154,16 +2154,16 @@ export function controlImplementationSteps(control, checks, options = {}) {
   if (!checks.implemented) steps.push(control.id === "control-strong-authentication" && options.targets?.length
     ? `Ensure MFA and unique accounts are enabled for ${options.targets.join(", ")}; check default credentials and admin roles.`
     : starterControlChecks[control.id]
-    || "Inspect the systems, people, vendors, or work this Control covers. Compare current practice with its statement and fix any gaps.");
+    || `Inspect the Systems, people, Vendors, and work linked to ${control.title || control.id}. Compare the actual configuration with this Control's statement and fix the specific gaps.`);
   const record = [];
-  if (!checks.owner) record.push("choose an owner");
-  if (!checks.scope) record.push("select the Systems this covers");
-  if (!checks.operationPattern) record.push("set when it runs");
-  if (!checks.procedure) record.push("write who does what and when in Procedure");
-  if (!checks.evidenceSource) record.push("link the tool or system that can show it happened");
+  if (!checks.owner) record.push("assign the actual owner from existing People or Appointments");
+  if (!checks.scope) record.push("link the in-scope Systems already in the Program");
+  if (!checks.operationPattern) record.push("record whether it runs continuously, per transaction, on a schedule, or after an event");
+  if (!checks.procedure) record.push("write the current actors, configuration, and procedure in Record Markdown");
+  if (!checks.evidenceSource) record.push("link the authoritative Component that can produce proof");
   if (!checks.policyMapping && checks.policyMapping !== undefined) record.push("link the Policy it implements");
   if (!checks.criteriaMapping && checks.criteriaMapping !== undefined) record.push("link the criteria it covers");
-  if (!checks.implementationDate) record.push("record the actual date it starts working when marking Implemented");
+  if (!checks.implementationDate) record.push("record the date the working implementation took effect when marking Implemented");
   if (checks.procedureRevision === false || checks.procedureEffective === false) {
     record.push("record the Procedure revision and effective date");
   }
@@ -2174,16 +2174,16 @@ export function controlImplementationSteps(control, checks, options = {}) {
     ? `Cover the missing evidence families: ${sourceTargets.length ? sourceTargets.join(" and ") : "this Control"}. For each, link an active Component with the matching kind, evidence owners, and report retrieval instructions.`
     : null;
   const queueStep = checks.workQueue === false
-    ? "Check the linked Obligations. Enable one with the owner and schedule for this Control's recurring or event work, or add one if none covers it."
+    ? "Inspect linked Obligations and their Policy basis. Enable a suitable existing rule with its owner and deadline, or add a rule only if no existing one covers this work. A scheduled rule does not prove a cycle occurred."
     : null;
   if (!checks.implemented) {
     if (sourceStep || queueStep) steps.push([sourceStep, queueStep].filter(Boolean).join(" "));
-    else if (checks.applicability === false) steps.push("Confirm this Control applies to the current Program scope with `review-applicability --scaffold --type control`.");
-    else steps.push("When these launch conditions hold, mark the Control Implemented. This asserts the practice works now; record proof from future cycles and events as they occur.");
+    else if (checks.applicability === false) steps.push("Compare this Control with the current Program scope and record its applicability decision with `review-applicability --scaffold --type control`; ask management only if the decision cannot be established from the scope and commitments.");
+    else steps.push("When these launch conditions hold, mark the Control Implemented with its real effective date. Record dated proof later, when a cycle or event actually occurs.");
   } else {
     if (sourceStep) steps.push(sourceStep);
     if (queueStep) steps.push(queueStep);
-    if (checks.applicability === false) steps.push("Confirm this Control applies to the current Program scope with `review-applicability --scaffold --type control`.");
+    if (checks.applicability === false) steps.push("Compare this Control with the current Program scope and record its applicability decision with `review-applicability --scaffold --type control`; ask management only if the decision cannot be established from the scope and commitments.");
   }
   return steps;
 }

package/src/retention.js

@@ -156,79 +156,106 @@ export async function resourceReviewRevision(loaded, resourceId) {
   return (await resourceReviewRevisions(loaded, [resourceId])).get(resourceId) || null;
 }
 
-export async function resourceReviewRevisions(loaded, ids, scopeHashInput = "legacy") {
+export async function resourceReviewRevisions(loaded, ids, scopeHashInput = "legacy", reviewer = null) {
   const wanted = new Set(ids);
   const entries = new Map(loaded.entries.map((entry) => [entry.record.id, entry]));
   const revisions = new Map();
   const reviewing = new Set();
-  const review = async (id) => {
-    if (revisions.has(id)) return revisions.get(id);
-    const entry = entries.get(id);
-    if (!entry || reviewing.has(id)) return null;
-    reviewing.add(id);
-    const parts = [reviewSource(loaded, entry, scopeHashInput)];
+  const review = async (id, heading = null) => {
+    const key = `${id}\0${heading || ""}`;
+    if (revisions.has(key)) return revisions.get(key);
+    const entry = effectiveReviewEntry(loaded, entries.get(id));
+    if (!entry || reviewing.has(key)) return null;
+    reviewing.add(key);
+    const parts = [reviewSource(loaded, entry, scopeHashInput, false, heading)];
+    let matchedSection = !heading;
     for (const markdown of reviewMarkdownEntries(loaded, entry, false)) {
       try {
-        parts.push(await readFile(resolveDataPath(loaded.root, markdown.path), "utf8"));
+        const source = entry.reviewCommit
+          ? entry.reviewFiles?.get(`data/${markdown.path}`)
+            ?? getFileAtRevision(loaded.root, entry.reviewCommit, `data/${markdown.path}`)
+          : await readFile(resolveDataPath(loaded.root, markdown.path), "utf8");
+        if (source !== null) {
+          const section = reviewedMarkdownSection(source, heading);
+          if (section !== null) { parts.push(section); matchedSection = true; }
+        }
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
     }
+    if (!matchedSection) { reviewing.delete(key); return null; }
+    let missingDependency = false;
     for (const sourceId of [...new Set(entry.record.sourceResourceIds || [])].sort()) {
-      const revision = await review(sourceId);
+      const revision = await review(sourceId, sourceHeading(entry.record, sourceId));
       if (revision) parts.push(`${sourceId}:${revisionDigest("content", revision) || revision}`);
+      else missingDependency = true;
     }
-    reviewing.delete(id);
+    reviewing.delete(key);
+    if (missingDependency) return null;
     const revision = contentRevision(parts.join("\n"));
-    revisions.set(id, revision);
+    revisions.set(key, revision);
     return revision;
   };
+  const selected = new Map();
   for (const id of wanted) {
-    await review(id);
+    selected.set(id, await review(id, sourceHeading(reviewer, id)));
   }
-  return new Map([...revisions].filter(([id]) => wanted.has(id)));
+  return new Map([...selected].filter(([, revision]) => revision));
 }
 
-export function resourceReviewRevisionsSync(loaded, ids, scopeHashInput = "legacy", legacySource = false, historicalCommit = null) {
+export function resourceReviewRevisionsSync(loaded, ids, scopeHashInput = "legacy", legacySource = false, historicalCommit = null, reviewer = null) {
   const wanted = new Set(ids);
   const entries = new Map(loaded.entries.map((entry) => [entry.record.id, entry]));
   const revisions = new Map();
   const reviewing = new Set();
-  const review = (id) => {
-    if (revisions.has(id)) return revisions.get(id);
-    const entry = entries.get(id);
-    if (!entry || reviewing.has(id)) return null;
-    reviewing.add(id);
-    const parts = [reviewSource(loaded, entry, scopeHashInput, legacySource)];
+  const review = (id, heading = null) => {
+    const key = `${id}\0${heading || ""}`;
+    if (revisions.has(key)) return revisions.get(key);
+    const entry = historicalCommit ? entries.get(id) : effectiveReviewEntry(loaded, entries.get(id));
+    if (!entry || reviewing.has(key)) return null;
+    reviewing.add(key);
+    const parts = [reviewSource(loaded, entry, scopeHashInput, legacySource, heading)];
+    let matchedSection = !heading;
     for (const markdown of reviewMarkdownEntries(loaded, entry, legacySource)) {
       try {
-        const source = historicalCommit
-          ? loaded.historicalFiles
-            ? loaded.historicalFiles.get(`data/${markdown.path}`) ?? null
-            : getFileAtRevision(loaded.root, historicalCommit, `data/${markdown.path}`)
+        const source = (historicalCommit || entry.reviewCommit)
+          ? loaded.historicalFiles?.get(`data/${markdown.path}`)
+            ?? entry.reviewFiles?.get(`data/${markdown.path}`)
+            ?? getFileAtRevision(loaded.root, historicalCommit || entry.reviewCommit, `data/${markdown.path}`)
           : readFileSync(resolveDataPath(loaded.root, markdown.path), "utf8");
-        if (source !== null) parts.push(source);
+        if (source !== null) {
+          const section = legacySource ? source : reviewedMarkdownSection(source, heading);
+          if (section !== null) { parts.push(section); matchedSection = true; }
+        }
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
     }
+    if (!matchedSection) { reviewing.delete(key); return null; }
+    let missingDependency = false;
     for (const sourceId of [...new Set(entry.record.sourceResourceIds || [])].sort()) {
-      const revision = review(sourceId);
+      const revision = review(sourceId, sourceHeading(entry.record, sourceId));
       if (revision) parts.push(`${sourceId}:${revisionDigest("content", revision) || revision}`);
+      else missingDependency = true;
     }
-    reviewing.delete(id);
+    reviewing.delete(key);
+    if (missingDependency) return null;
     const revision = contentRevision(parts.join("\n"));
-    revisions.set(id, revision);
+    revisions.set(key, revision);
     return revision;
   };
-  for (const id of wanted) review(id);
-  return new Map([...revisions].filter(([id]) => wanted.has(id)));
+  const selected = new Map();
+  for (const id of wanted) selected.set(id, review(id, sourceHeading(reviewer, id)));
+  return new Map([...selected].filter(([, revision]) => revision));
 }
 
-export function resourceReviewRevisionMatches(loaded, revisions, id, stored) {
-  const current = revisions.get(id);
+export function resourceReviewRevisionMatches(loaded, revisions, id, stored, reviewer = null) {
+  const current = sourceHeading(reviewer, id)
+    ? resourceReviewRevisionsSync(loaded, [id], "legacy", false, null, reviewer).get(id)
+    : revisions.get(id);
   if (!current || !revisionDigest("content", stored)) return false;
   if (revisionsMatch("content", stored, current)) return true;
+  if (sourceHeading(reviewer, id)) return false;
   const legacy = resourceReviewRevisionsSync(loaded, [id], "legacy", true).get(id);
   if (revisionsMatch("content", stored, legacy)) return true;
   // Version 0.16.0 used a bare digest as the hash input for scopeRevision.
@@ -293,7 +320,20 @@ export function retentionUses(loaded, program) {
   return [...new Map(uses.map((use) => [`${use.resource.id}:${use.informationTypeId}`, use])).values()];
 }
 
-function reviewSource(loaded, entry, scopeHashInput = "legacy", legacySource = false) {
+function reviewSource(loaded, entry, scopeHashInput = "legacy", legacySource = false, heading = null) {
+  if (heading && !legacySource) {
+    const governingFields = entry.record.type === "policy"
+      ? ["policyKind", "effectiveOn", "supersedesId", "parentPolicyId", "relatedPolicyIds", "relatedDocumentIds", "requirementIds", "audience", "acknowledgementRequired", "programRole", "reportingRouteRequirements"]
+      : ["documentKind", "workflowScope", "effectiveOn", "supersedesId", "systemIds", "controlIds", "relatedDocumentIds", "audience", "acknowledgementRequired", "trainingIds", "classificationId", "programRole", "componentIds", "reportingRouteRequirements"];
+    return JSON.stringify({
+      id: entry.record.id,
+      type: entry.record.type,
+      governingStatus: ["approved", "active"].includes(entry.record.status)
+        ? "approved" : entry.record.status || null,
+      ...Object.fromEntries(["extensions", "externalIds", ...governingFields].filter((field) => entry.record[field] !== undefined)
+        .map((field) => [field, entry.record[field]]))
+    });
+  }
   if (
     modelSupports(loaded.model, "retention-schedule-approval")
     && entry.record.type === "document"
@@ -330,9 +370,93 @@ function reviewMarkdownEntries(loaded, entry, legacySource) {
   return markdownEntries(loaded.model, entry.record);
 }
 
+const approvedReviewEntries = new WeakMap();
+
+function effectiveReviewEntry(loaded, entry) {
+  if (!entry || !loaded.root || !["policy", "document", "training"].includes(entry.record.type)) return entry;
+  if (!["draft", "in-review", "approved", "active"].includes(entry.record.status)) return entry;
+  if (approvedReviewContentMatches(loaded, entry)) return entry;
+  if (["approved", "active"].includes(entry.record.status)) return entry;
+  let cache = approvedReviewEntries.get(loaded.resources);
+  if (!cache) {
+    cache = new Map();
+    approvedReviewEntries.set(loaded.resources, cache);
+  }
+  if (cache.has(entry.record.id)) return cache.get(entry.record.id) || entry;
+  const context = reviewHistoryContext(loaded.root, loaded);
+  for (const commit of [...reviewHistoryCommits(context)].reverse()) {
+    const snapshot = reviewHistoricalWorkspace(context, commit);
+    const historical = snapshot?.entries.find(({ record }) => record.id === entry.record.id);
+    if (!historical || !approvedReviewContentMatches(snapshot, historical, commit)) continue;
+    const approved = { ...historical, reviewCommit: commit, reviewFiles: snapshot.historicalFiles };
+    cache.set(entry.record.id, approved);
+    return approved;
+  }
+  cache.set(entry.record.id, null);
+  return entry;
+}
+
+function approvedReviewContentMatches(loaded, entry, commit = null) {
+  if (!["approved", "active"].includes(entry.record.status)) return false;
+  const bindings = entry.record.approvedContentRevisions || entry.record.effectiveContentRevisions;
+  if (!bindings) return true;
+  for (const markdown of reviewMarkdownEntries(loaded, entry, false)) {
+    const source = commit
+      ? loaded.historicalFiles?.get(`data/${markdown.path}`)
+        ?? getFileAtRevision(loaded.root, commit, `data/${markdown.path}`)
+      : (() => {
+        try { return readFileSync(resolveDataPath(loaded.root, markdown.path), "utf8"); }
+        catch (error) { if (error.code === "ENOENT") return null; throw error; }
+      })();
+    if (!source || !revisionsMatch("content", bindings[markdown.path], contentRevision(source))) return false;
+  }
+  return true;
+}
+
+export function reviewedMarkdownSection(source, heading) {
+  if (!heading) return source;
+  const lines = source.split("\n");
+  const wanted = heading.trim().replace(/^#{1,6}\s+/, "").toLowerCase();
+  const headings = [];
+  const fencedLines = new Set();
+  let fence = null;
+  for (const [index, line] of lines.entries()) {
+    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+    if (fence) {
+      fencedLines.add(index);
+      if (marker?.[0] === fence[0] && marker.length >= fence.length
+        && /^\s*$/.test(line.slice(line.indexOf(marker) + marker.length))) fence = null;
+      continue;
+    }
+    if (marker) { fence = marker; fencedLines.add(index); continue; }
+    const match = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+    if (match) headings.push({ index, level: match[1].length, title: match[2].trim().toLowerCase() });
+  }
+  const matches = headings.filter(({ title }) => title === wanted);
+  if (matches.length !== 1) return null;
+  const selected = matches[0];
+  const ancestors = [];
+  for (const candidate of headings.filter(({ index }) => index < selected.index)) {
+    while (ancestors.length && ancestors.at(-1).level >= candidate.level) ancestors.pop();
+    ancestors.push(candidate);
+  }
+  const next = headings.find(({ index, level }) => index > selected.index && level <= selected.level);
+  const context = ancestors.map(({ index }) => {
+    const following = headings.find((candidate) => candidate.index > index);
+    return lines.slice(index, following?.index).filter((_, offset) => !fencedLines.has(index + offset)).join("\n").trim();
+  });
+  return [...context, lines.slice(selected.index, next?.index).join("\n").trim()].join("\n\n");
+}
+
+function sourceHeading(record, sourceId) {
+  const headings = record?.sourceSectionHeadings;
+  return headings && Object.hasOwn(headings, sourceId) && typeof headings[sourceId] === "string"
+    ? headings[sourceId] : null;
+}
+
 const reviewDecisionFields = {
   control: ["statement", "requirementIds", "code", "activity", "controlType", "operationMode", "operationPattern", "systemIds", "policyIds", "componentIds", "evidenceSourceComponentIds"],
-  commitment: ["commitmentKind", "statement", "systemIds", "sourceResourceIds", "requirementIds", "controlIds", "customerFacing", "effectiveOn", "reportingRouteRequirements"],
+  commitment: ["commitmentKind", "statement", "systemIds", "sourceResourceIds", "sourceSectionHeadings", "requirementIds", "controlIds", "customerFacing", "effectiveOn", "reportingRouteRequirements"],
   "complementary-control": ["responsibleParty", "statement", "systemIds", "vendorId", "requirementIds", "commitmentIds", "relatedControlIds", "sourceDocumentIds", "componentIds"],
   "source-coverage": ["sourceFamilyId", "coverageKind", "scopeResourceIds", "excludedPopulation", "collectionCadence", "reconciliationMethod", "validFrom", "validThrough", "componentId", "retentionScheduleItemIds"],
   system: ["purpose", "servicesProvided", "boundary", "exclusions", "criticality", "informationTypeIds", "classificationId", "internetExposed", "continuityObjectives"],
@@ -450,7 +574,7 @@ export function retentionRuleIsCurrent(rule, revisions, byId = new Map(), loaded
   const dependencyIds = retentionReviewResourceIds(rule, loaded);
   if (Object.keys(rule.reviewedSourceRevisions).length !== dependencyIds.length) return false;
   return dependencyIds.every((id) => (
-    resourceReviewRevisionMatches(loaded, revisions, id, rule.reviewedSourceRevisions?.[id])
+    resourceReviewRevisionMatches(loaded, revisions, id, rule.reviewedSourceRevisions?.[id], rule)
   ));
 }
 

package/src/server.js

@@ -627,9 +627,23 @@ export function createFilegrcServer(input = process.cwd(), options = {}) {
           return json(response, 400, { error: "Pass one or more safe resource IDs." });
         }
         const loaded = await loadWorkspace(input);
-        const revisions = await resourceReviewRevisions(loaded, ids);
+        const sourceSectionHeadings = Object.create(null);
+        for (const value of url.searchParams.getAll("section")) {
+          const separator = value.indexOf(":");
+          const id = value.slice(0, separator);
+          const heading = value.slice(separator + 1).trim();
+          if (separator < 1 || !ids.includes(id) || !heading || heading.length > 200) {
+            return json(response, 400, { error: "Each reviewed section must name a selected source and a Markdown heading." });
+          }
+          sourceSectionHeadings[id] = heading;
+        }
+        const revisions = await resourceReviewRevisions(loaded, ids, "legacy", { sourceSectionHeadings });
         const missing = ids.filter((id) => !revisions.has(id));
-        if (missing.length) return json(response, 404, { error: `Resources not found: ${missing.join(", ")}.` });
+        if (missing.length) return json(response, 404, {
+          error: missing.some((id) => sourceSectionHeadings[id])
+            ? `A selected source heading is missing or ambiguous: ${missing.filter((id) => sourceSectionHeadings[id]).join(", ")}.`
+            : `Resources not found: ${missing.join(", ")}.`
+        });
         return json(response, 200, { revisions: Object.fromEntries(revisions) });
       }
       if (request.method === "PUT" && url.pathname === "/api/content") {

package/src/validate.js

@@ -219,6 +219,19 @@ async function validateWorkspaceUnmeasured(input) {
       }
       validateNestedRelations(fieldName, value, field, loaded.model, byId, displayPath, diagnostics);
     }
+    if (record.sourceSectionHeadings) {
+      for (const [sourceId, heading] of Object.entries(record.sourceSectionHeadings)) {
+        if (!(record.sourceResourceIds || []).includes(sourceId)
+          || !["policy", "document"].includes(byId.get(sourceId)?.type)
+          || !String(heading || "").trim()) {
+          diagnostics.push(error(
+            "invalid-source-section",
+            displayPath,
+            `sourceSectionHeadings.${sourceId} must name a linked Policy or Document and a Markdown heading.`
+          ));
+        }
+      }
+    }
     validateIndependentApproval(record, byId, displayPath, diagnostics);
     validateCompletedObligationEvent(record, byId, loaded.model, displayPath, diagnostics);
     validateActionObligationRule(record, byId, displayPath, diagnostics);
@@ -1995,7 +2008,7 @@ function validateRetentionScheduleItem(record, loaded, byId, currentReviewRevisi
   const sources = retentionReviewResourceIds(record, loaded);
   const revisions = record.reviewedSourceRevisions || {};
   const missing = sources.filter((id) => (
-    !resourceReviewRevisionMatches(loaded, currentReviewRevisions, id, revisions[id])
+    !resourceReviewRevisionMatches(loaded, currentReviewRevisions, id, revisions[id], record)
   )).concat(Object.keys(revisions).filter((id) => !sources.includes(id)));
   if (missing.length) {
     diagnostics.push(error(

package/src/web.js

@@ -1231,7 +1231,7 @@ function controlLaunchLabel(state) {
   return ({
     planned: "Planned: launch conditions remain",
     partial: "Partially implemented: launch conditions remain",
-    "ready-to-implement": "Launch checks ready: confirm it works, then record the start date",
+    "ready-to-implement": "Launch checks ready: check the live configuration, then record its start date",
     "implemented-with-gaps": "Implemented with gaps: fix the launch checks",
     implemented: "Implemented"
   })[state] || "Control launch";
@@ -5358,6 +5358,8 @@ function editorField(type, name, field, value, required, editing, oneOfRequired
       control = stringMapEditor(value || {}, name, name === "reviewedSourceRevisions");
       const mapHelp = name === "reviewedSourceRevisions"
         ? "Bind the exact current JSON and Markdown revisions after reviewing every selected record."
+        : name === "sourceSectionHeadings"
+          ? "Use a linked Policy or Document ID and its exact Markdown heading. The selected section governs this decision."
         : "Add one named value per row.";
       return fieldWrap(name, "string-map", label, requiredMark, control, mapHelp, required);
     }
@@ -5558,7 +5560,11 @@ async function bindCurrentReviewRevisions(dialog, button) {
   setButtonBusy(button, true, "Binding…");
   let bound = false;
   try {
-    const query = ids.map((id) => "id=" + encodeURIComponent(id)).join("&");
+    const sections = [...dialog.querySelectorAll('[data-field-group="sourceSectionHeadings"] .string-map-row')]
+      .map((row) => [row.querySelector('[data-map-key]')?.value?.trim(), row.querySelector('[data-map-value]')?.value?.trim()])
+      .filter(([id, heading]) => id && heading);
+    const query = ids.map((id) => "id=" + encodeURIComponent(id))
+      .concat(sections.map(([id, heading]) => "section=" + encodeURIComponent(id + ":" + heading))).join("&");
     const response = await localFetch("/api/review-revisions?" + query);
     if (!response.ok) throw new Error(await responseMessage(response));
     const { revisions } = await response.json();
@@ -6775,6 +6781,7 @@ dialog::backdrop{background:rgba(0,0,24,.62)}
 @media(max-width:760px){.workflow-findings{grid-template-columns:1fr}}
 .choice-tag{overflow-wrap:normal;font-size:10px}.form-field[data-kind="structured-object"],.string-map-property{grid-column:1/-1}.string-map-row .text-button{text-transform:none;letter-spacing:0;color:var(--muted);font-size:11px}
 .form-field[data-kind="string-map"]{grid-column:1/-1}.string-map-actions{display:flex;flex-wrap:wrap;gap:7px}
+.form-field[data-field-group="sourceSectionHeadings"] .string-map-row{grid-template-columns:minmax(0,1fr) minmax(0,2fr) auto}
 @media(max-width:760px){.setup-banner>.button{justify-self:start}.setup-draft-state{justify-content:flex-start;flex-wrap:wrap;gap:12px 22px}.setup-draft-state .button{width:100%}}
 @media(max-width:760px){.string-map-row{grid-template-columns:1fr 1fr}.string-map-row .text-button{grid-column:1/-1;justify-self:start}}
 

package/src/workflow.js

@@ -466,13 +466,17 @@ function recordIncompleteReason(record, loaded, program) {
     return {
       state: "ready",
       requiredness: appointmentRequiredness(record, loaded.model),
-      message: "Assign a holder, confirm the authority and independence needed, then activate this Appointment on its actual start date."
+      message: "Check current People and scoped Appointments, assign a qualified holder, and record the actual authority and start date. Ask management only if the holder or independence decision is unresolved."
     };
   }
   const messages = {
     draft: "Add the required details, relationships, and Markdown before review.",
     planned: "Check this planned record against how your program works, then add the missing details.",
-    proposed: "Confirm the work, owner, schedule, and completion requirements before activation.",
+    proposed: ["obligation", "obligation-rule"].includes(record.type)
+      ? "Read the linked Policy and Control, fill the actual owner, schedule, deadline, and proof requirement, then activate the rule. Ask management only for a choice those sources do not settle."
+      : record.type === "reporting-route-set"
+        ? "Fill the normal and fallback reporting routes from approved contact details, commit the proposal, and obtain the required separate approval before it takes effect. Ask only for missing route or authority decisions."
+        : "Inspect the source facts and type guide, complete the proposal, and obtain the required review or approval before activation.",
     "in-review": "Have an independent reviewer approve the exact content revision.",
     open: "Complete this work with the required proof, or formally close it without completion.",
     "in-progress": "Finish the work, record the result, and link the completion proof.",
@@ -724,7 +728,7 @@ function reconciliationFindings(reconciliation) {
     state: "ready",
     severity: "warning",
     requiredness: "conditional",
-    title: `Confirm ${fieldLabel(candidate.eventType)}`,
+    title: `Resolve ${fieldLabel(candidate.eventType)} transition`,
     message: candidate.message,
     subject: candidate.subject,
     fieldPath: candidate.sourcePath,
@@ -1630,12 +1634,12 @@ function periodFinding(key, title, message, state, subject, actions, dependencie
 function auditClosureNextStep(status) {
   const steps = {
     planned: {
-      title: "Confirm the engagement and start audit preparation",
-      message: "Link the agreed engagement terms, confirm scope and management acknowledgement, then move the audit to in progress."
+      title: "Record the agreed engagement and start audit preparation",
+      message: "Read the signed engagement terms, link them, record the agreed scope and management acknowledgement, then move the audit to in progress. Ask for missing terms or acknowledgement only if unavailable."
     },
     "in-progress": {
       title: "Begin fieldwork",
-      message: "Finish management preparation, confirm the fieldwork dates, and move the audit to fieldwork when the CPA firm begins testing."
+      message: "Finish management preparation, record the fieldwork dates agreed with the CPA firm, and move the audit to fieldwork when testing begins. Ask for the dates only if they are not in the engagement correspondence."
     },
     fieldwork: {
       title: "Finish fieldwork and prepare the report",
@@ -1647,7 +1651,7 @@ function auditClosureNextStep(status) {
     },
     issued: {
       title: "Record final report delivery",
-      message: "Confirm the issued report evidence, opinion, report date, authorized recipient, and delivery receipt, then move the audit to delivered."
+      message: "Read the issued report and delivery record, enter the opinion, report date, authorized recipient, and receipt, then move the audit to delivered. Ask only for missing delivery facts."
     },
     delivered: {
       title: "Close the audit",