filegrc 0.11.0 → 0.12.0

package/src/index.js

@@ -7,6 +7,7 @@ export {
   SUPPORTED_MODEL_VERSIONS
 } from "../model/index.js";
 export { buildAgentGuide, findResourceReferences, listResourceTypes, scaffoldResourceMutation } from "./agent.js";
+export { saveAuditPopulation, scaffoldAuditPopulationCorrection } from "./audit-populations.js";
 export { assessAuditDocumentActivations, assessAuditPreparation, prepareAuditWorkspace } from "./audit-preparation.js";
 export { createNextAuditCycle, planNextAuditCycle } from "./audit-transition.js";
 export {
@@ -73,8 +74,12 @@ export {
   completeObligationEvent,
   completeObligationOccurrence,
   createObligationEvent,
+  activateObligationRule,
   planObligations,
-  scaffoldObligationCompletion
+  saveObligationOccurrence,
+  scaffoldObligationCompletion,
+  scaffoldObligationOccurrence,
+  scaffoldObligationRuleActivation
 } from "./obligations.js";
 export {
   planExternalReviewerGovernance,
@@ -82,6 +87,17 @@ export {
   setupExternalReviewerGovernance
 } from "./external-reviewer.js";
 export { assessEvidenceMap, assessProgramReadiness } from "./program-readiness.js";
+export {
+  approveReportingRouteSet,
+  assessReportingRoutePeriod,
+  assessReportingRouteSets,
+  cancelReportingRouteSet,
+  effectiveReportingRouteRequirements,
+  proposeReportingRouteSet,
+  reportingRouteLanesIndependent,
+  scaffoldReportingRouteSet
+} from "./reporting-route-sets.js";
+export { reportingRouteBindingExpectation } from "./reporting-route-integrity.js";
 export { planProgramAmendment } from "./program-amendment.js";
 export {
   buildAgentProgramPath,

package/src/model-migration.js

@@ -896,10 +896,12 @@ export async function planModelMigration(input = process.cwd(), options = {}) {
     : sourceVersion === "1" ? V1_TARGET_MODEL_VERSION
       : sourceVersion === "2" ? "3"
         : sourceVersion === "3" ? "4"
-            : sourceVersion === "4" ? "5"
-              : sourceVersion === "5" ? "6"
-                : sourceVersion === "6" ? "7"
-                  : ACTIVE_MODEL_VERSION;
+          : sourceVersion === "4" ? "5"
+            : sourceVersion === "5" ? "6"
+              : sourceVersion === "6" ? "7"
+                : sourceVersion === "7" ? "8"
+                  : sourceVersion === "8" ? "9"
+                    : ACTIVE_MODEL_VERSION;
   if (sourceVersion === requestedTarget) return emptyPlan(sourceVersion, requestedTarget);
   if (sourceVersion === "1" && requestedTarget === "2") {
     return planV1ToV2Migration(input, options);
@@ -919,9 +921,15 @@ export async function planModelMigration(input = process.cwd(), options = {}) {
   if (sourceVersion === "6" && requestedTarget === "7") {
     return planV6ToV7Migration(loaded);
   }
-  if (sourceVersion === "7" && requestedTarget === ACTIVE_MODEL_VERSION) {
+  if (sourceVersion === "7" && requestedTarget === "8") {
     return planV7ToV8Migration(loaded);
   }
+  if (sourceVersion === "8" && requestedTarget === "9") {
+    return planV8ToV9Migration(loaded);
+  }
+  if (sourceVersion === "9" && requestedTarget === ACTIVE_MODEL_VERSION) {
+    return planV9ToV10Migration(loaded);
+  }
   if (sourceVersion === "1" && requestedTarget === ACTIVE_MODEL_VERSION) {
     throw new Error(
       "Model v1 workspaces must migrate to model v2 first. "
@@ -2190,6 +2198,214 @@ async function planV7ToV8Migration(loaded) {
   };
 }
 
+async function planV8ToV9Migration(loaded) {
+  if (!loaded.workspace?.id) throw new Error("Model migration requires a valid Workspace record.");
+  const targetModel = loadModel("9");
+  const revisions = new Map(loaded.entries.map((entry) => [entry.record.id, contentRevision(entry.source)]));
+  const automatic = [];
+  const reviewRequired = [];
+  const unsupported = [];
+  const missing = [];
+  const manualActions = [];
+  const updates = [];
+
+  for (const original of loaded.resources) {
+    const record = structuredClone(original);
+    let changed = false;
+    if (original.type === "workspace") {
+      record.dataModelVersion = "9";
+      changed = true;
+      automatic.push(classifiedChange("automatic", original.id, "dataModelVersion", "Select model v9."));
+    }
+    if (original.type === "obligation" && !original.scheduleMode) {
+      record.scheduleMode = "legacy";
+      changed = true;
+      automatic.push(classifiedChange(
+        "automatic",
+        original.id,
+        "scheduleMode",
+        "Keep the existing schedule in legacy mode until management reviews and activates an Obligation rule."
+      ));
+      reviewRequired.push(classifiedChange(
+        "review-required",
+        original.id,
+        "ruleIds",
+        "Review the reusable schedule and population rule before adopting rolled-up occurrence reconciliation."
+      ));
+    }
+    if (original.type === "obligation-event" && Object.hasOwn(original, "transitionFingerprint")) {
+      delete record.transitionFingerprint;
+      changed = true;
+      automatic.push(classifiedChange(
+        "automatic",
+        original.id,
+        "transitionFingerprint",
+        "Remove the obsolete reconciliation fingerprint. Git history preserves the original transition binding."
+      ));
+    }
+    if (original.type === "collection-review" && original.status === "active" && !original.knowledgeCutoffAt) {
+      reviewRequired.push(classifiedChange(
+        "review-required",
+        original.id,
+        "knowledgeCutoffAt",
+        "Record a new Collection Review against a clean Git revision before using it for historical population proof."
+      ));
+    }
+    if (changed) updates.push(record);
+  }
+
+  const updatedById = new Map(updates.map((record) => [record.id, record]));
+  const migratedRecords = loaded.resources.map((record) => updatedById.get(record.id) || record);
+  await collectTargetValidationActions(loaded, migratedRecords, targetModel, missing, manualActions);
+  for (const item of [...missing, ...manualActions]) {
+    unsupported.push(classifiedChange(
+      "unsupported",
+      item.resourceId,
+      item.field,
+      item.message || `Resolve ${item.field} before applying the model v9 migration.`
+    ));
+  }
+  const ready = unsupported.length === 0;
+  return {
+    schemaVersion: 2,
+    sourceModelVersion: "8",
+    targetModelVersion: "9",
+    ready,
+    missing,
+    conflicts: [],
+    manualActions,
+    classifications: { automatic, reviewRequired, unsupported },
+    notes: [
+      "Existing Obligation schedules remain in legacy mode until management activates reviewed rule revisions.",
+      "Existing Collection Reviews remain records, but only new Git-bound reviews can prove a historical population."
+    ],
+    migrationReport: {},
+    summary: {
+      create: 0,
+      update: updates.length,
+      automatic: automatic.length,
+      reviewRequired: reviewRequired.length,
+      unsupported: unsupported.length
+    },
+    fileDiff: {
+      create: [],
+      update: updates.map((record) => ({
+        type: record.type,
+        id: record.id,
+        before: loaded.resources.find(({ id }) => id === record.id),
+        after: record
+      }))
+    },
+    changes: {
+      create: [],
+      update: updates,
+      expectedRevisions: Object.fromEntries(updates.map(({ id }) => [id, revisions.get(id)])),
+      validateWholeWorkspace: true,
+      targetModelVersion: "9"
+    }
+  };
+}
+
+async function planV9ToV10Migration(loaded) {
+  if (!loaded.workspace?.id) throw new Error("Model migration requires a valid Workspace record.");
+  const targetModel = loadModel("10");
+  const revisions = new Map(loaded.entries.map((entry) => [entry.record.id, contentRevision(entry.source)]));
+  const automatic = [];
+  const reviewRequired = [];
+  const unsupported = [];
+  const missing = [];
+  const manualActions = [];
+  const updates = [];
+
+  for (const original of loaded.resources) {
+    const record = structuredClone(original);
+    let changed = false;
+    if (record.type === "workspace") {
+      record.dataModelVersion = "10";
+      automatic.push(classifiedChange("automatic", record.id, "dataModelVersion", "Select model v10."));
+      changed = true;
+    }
+    if (record.type === "reporting-route") {
+      if (record.status === "planned") {
+        record.status = "deprecated-draft";
+        automatic.push(classifiedChange(
+          "automatic",
+          record.id,
+          "status",
+          "Mark this unfinished model v9 route as a deprecated draft."
+        ));
+        changed = true;
+      }
+      reviewRequired.push(classifiedChange(
+        "review-required",
+        record.id,
+        "reporting-route-set",
+        "Scaffold one Reporting Route Set for the Program and purpose. Confirm the Program, paired lanes, approval authority, actual event time, timezone, and any structured source requirements instead of inferring them."
+      ));
+    }
+    if (record.type === "attestation" && (record.reportingRouteId || record.reportingRouteRevision)) {
+      reviewRequired.push(classifiedChange(
+        "review-required",
+        record.id,
+        "reportingRouteSetId",
+        "The preserved legacy scalar route binding cannot prove a Route Set revision. Keep the historical Attestation unchanged, and use a committed Route Set binding for future delivery proof."
+      ));
+    }
+    if (changed) updates.push(record);
+  }
+
+  const updatedById = new Map(updates.map((record) => [record.id, record]));
+  const migratedRecords = loaded.resources.map((record) => updatedById.get(record.id) || record);
+  await collectTargetValidationActions(loaded, migratedRecords, targetModel, missing, manualActions);
+  for (const item of [...missing, ...manualActions]) {
+    unsupported.push(classifiedChange(
+      "unsupported",
+      item.resourceId,
+      item.field,
+      item.message || `Resolve ${item.field} before applying the model v10 migration.`
+    ));
+  }
+  return {
+    schemaVersion: 2,
+    sourceModelVersion: "9",
+    targetModelVersion: "10",
+    ready: unsupported.length === 0,
+    missing,
+    conflicts: [],
+    manualActions,
+    classifications: { automatic, reviewRequired, unsupported },
+    notes: [
+      "Legacy Reporting Routes remain visible as migration-only records and cannot become effective Route Sets.",
+      "The migration does not infer a Program, purpose lineage, paired lane, authority, approval time, timezone, or evidence judgment.",
+      "Use the Route Set scaffold and a reviewed Git diff to create current facts."
+    ],
+    migrationReport: {},
+    summary: {
+      create: 0,
+      update: updates.length,
+      automatic: automatic.length,
+      reviewRequired: reviewRequired.length,
+      unsupported: unsupported.length
+    },
+    fileDiff: {
+      create: [],
+      update: updates.map((record) => ({
+        type: record.type,
+        id: record.id,
+        before: loaded.resources.find(({ id }) => id === record.id),
+        after: record
+      }))
+    },
+    changes: {
+      create: [],
+      update: updates,
+      expectedRevisions: Object.fromEntries(updates.map(({ id }) => [id, revisions.get(id)])),
+      validateWholeWorkspace: true,
+      targetModelVersion: "10"
+    }
+  };
+}
+
 function normalizeDocumentScopeDecision(value) {
   const candidate = typeof value === "object" && value
     ? value.workflowScope || value.scope