@tsantosfp_2026/piece-coach-migration-ai 1.0.1 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsantosfp_2026/piece-coach-migration-ai",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "main": "./src/index.js",
   "dependencies": {},
   "files": [

package/src/index.js

@@ -52796,9 +52796,29 @@ var require_output_schemas = __commonJS({
           { key: "source_text", label: "Source Text" },
           { key: "source_locators", label: "Source Locators", listItems: [] },
           { key: "source_evidence_references", label: "Source Evidence", labelKey: "canonical_field", listItems: evidenceFields },
+          { key: "evidence_pool", label: "Evidence Pool", labelKey: "evidence_class", listItems: [
+            { key: "evidence_reference", label: "Evidence Reference" },
+            { key: "evidence_class", label: "Evidence Class" },
+            { key: "canonical_field", label: "Canonical Field" },
+            { key: "page_url", label: "Page URL", format: "url" },
+            { key: "source_locator", label: "Source Locator" },
+            { key: "source_text", label: "Source Text" },
+            { key: "relevance_class", label: "Relevance Class" }
+          ] },
+          { key: "grounding", label: "Grounding Records", labelKey: "canonical_field", listItems: [
+            { key: "canonical_field", label: "Canonical Field" },
+            { key: "grounding_status", label: "Grounding Status" },
+            { key: "grounding_evidence_references", label: "Grounding Evidence References", listItems: [] },
+            { key: "grounding_basis", label: "Grounding Basis" }
+          ] },
           { key: "evidence_status", label: "Evidence Status" },
           { key: "source_packet_digest", label: "Source Packet Digest" }
         ] },
+        { key: "manualFinalizationFacts", label: "Manual Finalization Facts", labelKey: "canonical_field", listItems: [
+          { key: "canonical_field", label: "Canonical Field" },
+          { key: "disposition", label: "Disposition" },
+          { key: "reason", label: "Reason" }
+        ] },
         { key: "pendingNarrativeFields", label: "Pending Narrative Fields", listItems: [] },
         { key: "testimonialCandidates", label: "Testimonial Candidates", labelKey: "canonical_field", listItems: [{ key: "canonical_field", label: "Canonical Field" }, { key: "status", label: "Status" }, { key: "value", label: "Value" }] },
         { key: "humanReview", label: "Human Review", children: [{ key: "review_item_count", label: "Review Item Count", format: "number" }, { key: "items", label: "Review Items", listItems: [{ key: "canonical_field", label: "Canonical Field" }, { key: "status", label: "Status" }] }] },
@@ -52826,23 +52846,335 @@ var require_output_schemas = __commonJS({
   }
 });
 
+// dist/src/lib/source-policy.generated.js
+var require_source_policy_generated = __commonJS({
+  "dist/src/lib/source-policy.generated.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SOURCE_EVIDENCE_POLICY = exports2.SOURCE_POLICY_AUTHORITY = void 0;
+    exports2.SOURCE_POLICY_AUTHORITY = {
+      contractId: "OPENCODE_AI_ENRICHMENT_V1_2",
+      contractVersion: "1.2.0",
+      sha256: "b0529ae1d72659e5b1d211d9d7ac500550e9cf65aca971dd0cc1f3df6acbd15b",
+      producerRelevanceSha256: "200d2b9b876bd6d00806e9161b2d2a7cdbf976441b56ab0c5047337fff7a15cc"
+    };
+    exports2.SOURCE_EVIDENCE_POLICY = {
+      "ABOUT_V1": {
+        "groundingFieldAllowlist": [
+          "about.hero.heading",
+          "about.intro.body",
+          "about.bio.long",
+          "about.philosophy.heading",
+          "about.philosophy.body",
+          "about.why_coaching.heading",
+          "about.why_coaching.body",
+          "about.industries.heading",
+          "about.industry_1.title",
+          "about.industry_1.description",
+          "about.industry_2.title",
+          "about.industry_2.description",
+          "about.industry_3.title",
+          "about.industry_3.description",
+          "coach.title",
+          "coach.location.city",
+          "coach.location.state",
+          "coach.city_state",
+          "coach.service_area_heading",
+          "coach.service_area_line"
+        ],
+        "factFieldAllowlist": [
+          "coach.title",
+          "coach.first_name",
+          "coach.last_name",
+          "verified_context.approved_career_facts",
+          "verified_context.verified_media",
+          "verified_context.approved_service_labels"
+        ],
+        "destinationGroundingMap": {
+          "about.hero.heading": {
+            "relevant_relevance_classes": [
+              "ABOUT_BIOGRAPHY_NARRATIVE",
+              "IDENTITY_FACT",
+              "PRACTICE_FACT"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "about.intro.body": {
+            "relevant_relevance_classes": [
+              "ABOUT_BIOGRAPHY_NARRATIVE",
+              "IDENTITY_FACT",
+              "PRACTICE_FACT"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "about.bio.long": {
+            "relevant_relevance_classes": [
+              "ABOUT_BIOGRAPHY_NARRATIVE",
+              "PRACTICE_FACT"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "about.philosophy.heading": {
+            "relevant_relevance_classes": [
+              "ABOUT_PHILOSOPHY_NARRATIVE"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "about.philosophy.body": {
+            "relevant_relevance_classes": [
+              "ABOUT_PHILOSOPHY_NARRATIVE"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "about.why_coaching.heading": {
+            "relevant_relevance_classes": [
+              "ABOUT_WHY_COACHING_NARRATIVE"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "about.why_coaching.body": {
+            "relevant_relevance_classes": [
+              "ABOUT_WHY_COACHING_NARRATIVE"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "about.industries.heading": {
+            "relevant_relevance_classes": [
+              "INDUSTRIES_FACT"
+            ],
+            "missing_value_authority": "CONDITIONAL_OMISSION_INDUSTRIES_HEADING"
+          }
+        },
+        "sourceFieldRelevanceMap": {
+          "about.hero.heading": "ABOUT_BIOGRAPHY_NARRATIVE",
+          "about.intro.body": "ABOUT_BIOGRAPHY_NARRATIVE",
+          "about.bio.long": "ABOUT_BIOGRAPHY_NARRATIVE",
+          "about.philosophy.heading": "ABOUT_PHILOSOPHY_NARRATIVE",
+          "about.philosophy.body": "ABOUT_PHILOSOPHY_NARRATIVE",
+          "about.why_coaching.heading": "ABOUT_WHY_COACHING_NARRATIVE",
+          "about.why_coaching.body": "ABOUT_WHY_COACHING_NARRATIVE",
+          "about.industries.heading": "INDUSTRIES_FACT",
+          "about.industry_1.title": "INDUSTRIES_FACT",
+          "about.industry_1.description": "INDUSTRIES_FACT",
+          "about.industry_2.title": "INDUSTRIES_FACT",
+          "about.industry_2.description": "INDUSTRIES_FACT",
+          "about.industry_3.title": "INDUSTRIES_FACT",
+          "about.industry_3.description": "INDUSTRIES_FACT",
+          "coach.title": "PRACTICE_FACT",
+          "coach.city_state": "PRACTICE_FACT",
+          "coach.service_area_heading": "PRACTICE_FACT",
+          "coach.service_area_line": "PRACTICE_FACT",
+          "coach.first_name": "IDENTITY_FACT",
+          "coach.last_name": "IDENTITY_FACT",
+          "verified_context.approved_career_facts": "ABOUT_BIOGRAPHY_NARRATIVE",
+          "verified_context.verified_media": "ABOUT_BIOGRAPHY_NARRATIVE",
+          "verified_context.approved_service_labels": "PRACTICE_FACT"
+        }
+      },
+      "BUSINESS_COACHING_V1": {
+        "groundingFieldAllowlist": [
+          "business_coaching.hero.heading",
+          "business_coaching.hero.body",
+          "business_coaching.intro.body",
+          "coach.title",
+          "coach.location.city",
+          "coach.location.state",
+          "coach.city_state",
+          "coach.service_area_heading",
+          "coach.service_area_line"
+        ],
+        "factFieldAllowlist": [
+          "coach.title",
+          "verified_context.approved_service_labels"
+        ],
+        "destinationGroundingMap": {
+          "business_coaching.hero.heading": {
+            "relevant_relevance_classes": [
+              "BUSINESS_COACHING_NARRATIVE",
+              "PRACTICE_FACT"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "business_coaching.hero.body": {
+            "relevant_relevance_classes": [
+              "BUSINESS_COACHING_NARRATIVE",
+              "PRACTICE_FACT"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "business_coaching.intro.body": {
+            "relevant_relevance_classes": [
+              "BUSINESS_COACHING_NARRATIVE"
+            ],
+            "missing_value_authority": "NONE"
+          }
+        },
+        "sourceFieldRelevanceMap": {
+          "business_coaching.hero.heading": "BUSINESS_COACHING_NARRATIVE",
+          "business_coaching.hero.body": "BUSINESS_COACHING_NARRATIVE",
+          "business_coaching.intro.body": "BUSINESS_COACHING_NARRATIVE",
+          "coach.title": "PRACTICE_FACT",
+          "coach.city_state": "PRACTICE_FACT",
+          "coach.service_area_heading": "PRACTICE_FACT",
+          "coach.service_area_line": "PRACTICE_FACT",
+          "verified_context.approved_service_labels": "PRACTICE_FACT"
+        }
+      },
+      "EXECUTIVE_COACHING_V1": {
+        "groundingFieldAllowlist": [
+          "executive_coaching.hero.heading",
+          "executive_coaching.hero.body",
+          "coach.title",
+          "coach.location.city",
+          "coach.location.state",
+          "coach.city_state",
+          "coach.service_area_heading",
+          "coach.service_area_line"
+        ],
+        "factFieldAllowlist": [
+          "coach.title",
+          "verified_context.approved_service_labels"
+        ],
+        "destinationGroundingMap": {
+          "executive_coaching.hero.heading": {
+            "relevant_relevance_classes": [
+              "EXECUTIVE_COACHING_NARRATIVE",
+              "PRACTICE_FACT"
+            ],
+            "missing_value_authority": "NONE"
+          },
+          "executive_coaching.hero.body": {
+            "relevant_relevance_classes": [
+              "EXECUTIVE_COACHING_NARRATIVE",
+              "PRACTICE_FACT"
+            ],
+            "missing_value_authority": "NONE"
+          }
+        },
+        "sourceFieldRelevanceMap": {
+          "executive_coaching.hero.heading": "EXECUTIVE_COACHING_NARRATIVE",
+          "executive_coaching.hero.body": "EXECUTIVE_COACHING_NARRATIVE",
+          "coach.title": "PRACTICE_FACT",
+          "coach.city_state": "PRACTICE_FACT",
+          "coach.service_area_heading": "PRACTICE_FACT",
+          "coach.service_area_line": "PRACTICE_FACT",
+          "verified_context.approved_service_labels": "PRACTICE_FACT"
+        }
+      },
+      "RESULTS_V1": {
+        "groundingFieldAllowlist": [
+          "results.intro.body"
+        ],
+        "factFieldAllowlist": [
+          "coach.full_name",
+          "coach.first_name",
+          "coach.last_name",
+          "verified_context.approved_career_facts",
+          "verified_context.approved_service_labels"
+        ],
+        "destinationGroundingMap": {
+          "results.intro.body": {
+            "relevant_relevance_classes": [
+              "RESULTS_NARRATIVE"
+            ],
+            "missing_value_authority": "D14_RESULTS_BASELINE"
+          }
+        },
+        "sourceFieldRelevanceMap": {
+          "results.intro.body": "RESULTS_NARRATIVE",
+          "coach.full_name": "IDENTITY_FACT",
+          "coach.first_name": "IDENTITY_FACT",
+          "coach.last_name": "IDENTITY_FACT",
+          "verified_context.approved_career_facts": "ABOUT_BIOGRAPHY_NARRATIVE",
+          "verified_context.approved_service_labels": "PRACTICE_FACT"
+        }
+      },
+      "CONTACT_V1": {
+        "groundingFieldAllowlist": [
+          "contact.hero.heading",
+          "contact.intro.body"
+        ],
+        "factFieldAllowlist": [
+          "coach.full_name",
+          "coach.first_name",
+          "coach.last_name",
+          "verified_context.approved_service_labels"
+        ],
+        "destinationGroundingMap": {
+          "contact.hero.heading": {
+            "relevant_relevance_classes": [
+              "CONTACT_NARRATIVE"
+            ],
+            "missing_value_authority": "D15_CONTACT_BASELINE"
+          },
+          "contact.intro.body": {
+            "relevant_relevance_classes": [
+              "CONTACT_NARRATIVE"
+            ],
+            "missing_value_authority": "D15_CONTACT_BASELINE"
+          }
+        },
+        "sourceFieldRelevanceMap": {
+          "contact.hero.heading": "CONTACT_NARRATIVE",
+          "contact.intro.body": "CONTACT_NARRATIVE",
+          "coach.full_name": "IDENTITY_FACT",
+          "coach.first_name": "IDENTITY_FACT",
+          "coach.last_name": "IDENTITY_FACT",
+          "verified_context.approved_service_labels": "PRACTICE_FACT"
+        }
+      },
+      "DISCOVERY_CALL_V1": {
+        "groundingFieldAllowlist": [
+          "discovery_call.hero.body"
+        ],
+        "factFieldAllowlist": [
+          "coach.full_name",
+          "coach.first_name",
+          "coach.last_name",
+          "verified_context.approved_service_labels"
+        ],
+        "destinationGroundingMap": {
+          "discovery_call.hero.body": {
+            "relevant_relevance_classes": [
+              "DISCOVERY_CALL_NARRATIVE"
+            ],
+            "missing_value_authority": "D16_DISCOVERY_CALL_BASELINE"
+          }
+        },
+        "sourceFieldRelevanceMap": {
+          "discovery_call.hero.body": "DISCOVERY_CALL_NARRATIVE",
+          "coach.full_name": "IDENTITY_FACT",
+          "coach.first_name": "IDENTITY_FACT",
+          "coach.last_name": "IDENTITY_FACT",
+          "verified_context.approved_service_labels": "PRACTICE_FACT"
+        }
+      }
+    };
+  }
+});
+
 // dist/src/lib/contract.js
 var require_contract = __commonJS({
   "dist/src/lib/contract.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ALL_OUTPUT_KEYS = exports2.PROMPT_DEFINITIONS = exports2.PROMPT_IDS = exports2.CONTRACT_VERSION = exports2.CONTRACT_ID = void 0;
+    exports2.conditionallyOmittedKeys = conditionallyOmittedKeys;
+    exports2.effectiveOutputKeys = effectiveOutputKeys;
+    exports2.conditionallyOmittedKeysFromGrounding = conditionallyOmittedKeysFromGrounding;
     exports2.isObject = isObject;
     exports2.sha256Canonical = sha256Canonical;
     exports2.requiredOutputSchemaForPrompt = requiredOutputSchemaForPrompt;
+    exports2.effectiveOutputSchemaForPrompt = effectiveOutputSchemaForPrompt;
     exports2.assertCanonicalSourcePacket = assertCanonicalSourcePacket;
     exports2.buildBoundedNarrativeJob = buildBoundedNarrativeJob;
     exports2.assertBoundedJob = assertBoundedJob;
     exports2.validateNarrativeResponse = validateNarrativeResponse;
     exports2.narrativeFailure = narrativeFailure;
     var node_crypto_1 = require("node:crypto");
-    exports2.CONTRACT_ID = "OPENCODE_AI_ENRICHMENT_V1_1";
-    exports2.CONTRACT_VERSION = "1.1.0";
+    var source_policy_generated_1 = require_source_policy_generated();
+    exports2.CONTRACT_ID = "OPENCODE_AI_ENRICHMENT_V1_2";
+    exports2.CONTRACT_VERSION = "1.2.0";
     exports2.PROMPT_IDS = ["ABOUT_V1", "BUSINESS_COACHING_V1", "EXECUTIVE_COACHING_V1", "RESULTS_V1", "CONTACT_V1", "DISCOVERY_CALL_V1"];
     var COMMON_CONTEXT = ["coach.full_name", "coach.first_name", "coach.last_name", "coach.title"];
     var LOCATION_CONTEXT = ["coach_identity.location.city", "coach_identity.location.state"];
@@ -52861,48 +53193,111 @@ var require_contract = __commonJS({
           "about.industries.heading": "PLAIN_TEXT_STRING"
         },
         exactCopyKeys: [],
-        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "about.industry_1.title", "about.industry_1.description", "about.industry_2.title", "about.industry_2.description", "about.industry_3.title", "about.industry_3.description", "verified_context.approved_career_facts", "verified_context.verified_media", "verified_context.approved_service_labels"]
+        conditionalKeys: [{ canonicalField: "about.industries.heading", requiredWhen: "INDUSTRIES_GROUP populated_fields >= 1" }],
+        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "about.industry_1.title", "about.industry_1.description", "about.industry_2.title", "about.industry_2.description", "about.industry_3.title", "about.industry_3.description", "verified_context.approved_career_facts", "verified_context.verified_media", "verified_context.approved_service_labels"],
+        sourcePolicy: source_policy_generated_1.SOURCE_EVIDENCE_POLICY.ABOUT_V1
       },
       BUSINESS_COACHING_V1: {
         packetName: "AI Source \u2014 Business Coaching",
         outputKeys: ["business_coaching.hero.heading", "business_coaching.hero.body", "business_coaching.intro.body"],
         formats: { "business_coaching.hero.heading": "PLAIN_TEXT_STRING", "business_coaching.hero.body": "PLAIN_TEXT_STRING", "business_coaching.intro.body": "HTML_FRAGMENT_STRING" },
         exactCopyKeys: [],
-        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels", "verified_context.approved_career_facts"]
+        conditionalKeys: [],
+        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels", "verified_context.approved_career_facts"],
+        sourcePolicy: source_policy_generated_1.SOURCE_EVIDENCE_POLICY.BUSINESS_COACHING_V1
       },
       EXECUTIVE_COACHING_V1: {
         packetName: "AI Source \u2014 Executive Coaching",
         outputKeys: ["executive_coaching.hero.heading", "executive_coaching.hero.body"],
         formats: { "executive_coaching.hero.heading": "PLAIN_TEXT_STRING", "executive_coaching.hero.body": "PLAIN_TEXT_STRING" },
         exactCopyKeys: [],
-        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels", "verified_context.approved_career_facts"]
+        conditionalKeys: [],
+        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels", "verified_context.approved_career_facts"],
+        sourcePolicy: source_policy_generated_1.SOURCE_EVIDENCE_POLICY.EXECUTIVE_COACHING_V1
       },
       RESULTS_V1: {
         packetName: "AI Source \u2014 Results",
         outputKeys: ["results.intro.body"],
         formats: { "results.intro.body": "PLAIN_TEXT_STRING" },
         exactCopyKeys: [],
-        allowedContextKeys: [...COMMON_CONTEXT, "verified_context.approved_career_facts", "verified_context.approved_service_labels"]
+        conditionalKeys: [],
+        allowedContextKeys: [...COMMON_CONTEXT, "verified_context.approved_career_facts", "verified_context.approved_service_labels"],
+        sourcePolicy: source_policy_generated_1.SOURCE_EVIDENCE_POLICY.RESULTS_V1
       },
       CONTACT_V1: {
         packetName: "AI Source \u2014 Contact",
         outputKeys: ["contact.hero.heading", "contact.intro.body"],
         formats: { "contact.hero.heading": "PLAIN_TEXT_STRING", "contact.intro.body": "PLAIN_TEXT_STRING" },
         exactCopyKeys: ["contact.hero.heading", "contact.intro.body"],
-        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels"]
+        conditionalKeys: [],
+        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels"],
+        sourcePolicy: source_policy_generated_1.SOURCE_EVIDENCE_POLICY.CONTACT_V1
       },
       DISCOVERY_CALL_V1: {
         packetName: "AI Source \u2014 Discovery Call",
         outputKeys: ["discovery_call.hero.body"],
         formats: { "discovery_call.hero.body": "PLAIN_TEXT_STRING" },
         exactCopyKeys: ["discovery_call.hero.body"],
-        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels"]
+        conditionalKeys: [],
+        allowedContextKeys: [...COMMON_CONTEXT, ...LOCATION_CONTEXT, "verified_context.approved_service_labels"],
+        sourcePolicy: source_policy_generated_1.SOURCE_EVIDENCE_POLICY.DISCOVERY_CALL_V1
       }
     };
     exports2.ALL_OUTPUT_KEYS = exports2.PROMPT_IDS.flatMap((id) => [...exports2.PROMPT_DEFINITIONS[id].outputKeys]);
-    var JOB_KEYS = ["prompt_id", "source_text", "source_evidence", "verified_factual_context", "required_output_schema", "source_locators", "source_packet_digest", "contract_version"];
+    function conditionallyOmittedKeys(promptId, conditionalSectionStates) {
+      const definition = exports2.PROMPT_DEFINITIONS[promptId];
+      if (!definition.conditionalKeys.length)
+        return [];
+      const omitted = [];
+      for (const conditional of definition.conditionalKeys) {
+        if (conditional.requiredWhen !== "INDUSTRIES_GROUP populated_fields >= 1")
+          throw new Error("BOUNDED_AI_CONDITIONAL_KEY_POLICY_INVALID");
+        const industries = conditionalSectionStates.find((state) => state.group === "INDUSTRIES_GROUP");
+        if (!industries)
+          throw new Error("BOUNDED_AI_CONDITIONAL_STATE_REQUIRED");
+        if (Number(industries.populated_fields ?? 0) === 0)
+          omitted.push(conditional.canonicalField);
+      }
+      return omitted;
+    }
+    function effectiveOutputKeys(promptId, grounding) {
+      const omitted = new Set(conditionallyOmittedKeysFromGrounding(promptId, grounding));
+      return exports2.PROMPT_DEFINITIONS[promptId].outputKeys.filter((key) => !omitted.has(key));
+    }
+    function conditionallyOmittedKeysFromGrounding(promptId, grounding) {
+      const conditionalFields = new Set(exports2.PROMPT_DEFINITIONS[promptId].conditionalKeys.map((key) => key.canonicalField));
+      if (!conditionalFields.size) {
+        for (const record of grounding)
+          if (record.grounding_status === "CONDITIONALLY_OMITTED")
+            throw new Error("BOUNDED_AI_CONDITIONAL_KEY_POLICY_INVALID");
+        return [];
+      }
+      const omitted = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const record of grounding) {
+        const field = String(record.canonical_field ?? "");
+        if (!conditionalFields.has(field))
+          continue;
+        if (seen.has(field))
+          throw new Error("BOUNDED_AI_GROUNDING_DUPLICATE");
+        seen.add(field);
+        if (record.grounding_status === "CONDITIONALLY_OMITTED")
+          omitted.push(field);
+        else if (record.grounding_status !== "GROUNDED" && record.grounding_status !== "NO_SUPPORTING_EVIDENCE")
+          throw new Error("BOUNDED_AI_CONDITIONAL_STATUS_INVALID");
+      }
+      for (const field of conditionalFields)
+        if (!seen.has(field))
+          throw new Error("BOUNDED_AI_CONDITIONAL_STATE_REQUIRED");
+      return omitted;
+    }
+    var GROUNDING_RECORD_KEYS = ["canonical_field", "grounding_status", "grounding_evidence_references", "grounding_basis"];
+    var GROUNDING_STATUSES = ["GROUNDED", "NO_SUPPORTING_EVIDENCE", "CONDITIONALLY_OMITTED"];
+    var TEMPLATE_BASELINE_KEYS = ["manifest_digest", "manifest_version", "elements"];
+    var TEMPLATE_BASELINE_ELEMENT_KEYS = ["element_id", "element_type", "pages_rendered", "section_name", "captured_content", "content_sha256"];
+    var JOB_KEYS = ["prompt_id", "source_text", "source_evidence", "verified_factual_context", "required_output_schema", "source_locators", "source_packet_digest", "contract_version", "grounding", "template_baseline"];
     var RESPONSE_KEYS = ["contract_id", "prompt_id", "status", "source_packet_digest", "outputs", "provenance", "no_new_facts_attestation", "errors"];
-    var PACKET_KEYS = ["packet_name", "prompt_id", "logical_source_column_name", "source_text", "source_locators", "source_page_references", "source_evidence_references", "evidence_status", "source_packet_digest"];
+    var PACKET_KEYS = ["packet_name", "prompt_id", "logical_source_column_name", "source_text", "source_locators", "source_page_references", "source_evidence_references", "evidence_pool", "grounding", "evidence_status", "source_packet_digest"];
     var EVIDENCE_KEYS = ["evidence_reference", "canonical_field", "page_url", "page_title", "source_locator", "source_text"];
     var DIGEST = /^sha256:[0-9a-f]{64}$/;
     function isObject(value) {
@@ -52944,18 +53339,100 @@ var require_contract = __commonJS({
         properties: Object.fromEntries(definition.outputKeys.map((key) => [key, { type: "string", minLength: 1, output_format: definition.formats[key] }]))
       };
     }
-    function assertEvidence(evidence, definition, index) {
+    function effectiveOutputSchemaForPrompt(promptId, grounding) {
+      const definition = exports2.PROMPT_DEFINITIONS[promptId];
+      const effective = effectiveOutputKeys(promptId, grounding);
+      return {
+        type: "object",
+        additionalProperties: false,
+        required: [...effective],
+        properties: Object.fromEntries(effective.map((key) => [key, { type: "string", minLength: 1, output_format: definition.formats[key] }]))
+      };
+    }
+    function assertEvidence(evidence, index) {
       assertExactKeys(evidence, EVIDENCE_KEYS, `SOURCE_EVIDENCE_${index}`);
       const { evidence_reference: reference, ...digestInput } = evidence;
       if (reference !== sha256Canonical(digestInput))
         throw new Error(`SOURCE_EVIDENCE_${index}_DIGEST_INVALID`);
-      if (typeof evidence.canonical_field !== "string" || !definition.outputKeys.includes(evidence.canonical_field))
+      if (typeof evidence.canonical_field !== "string" || !evidence.canonical_field.trim())
         throw new Error(`SOURCE_EVIDENCE_${index}_FIELD_INVALID`);
       for (const key of ["page_url", "page_title", "source_locator", "source_text"])
         if (typeof evidence[key] !== "string" || !evidence[key].trim())
           throw new Error(`SOURCE_EVIDENCE_${index}_${key.toUpperCase()}_INVALID`);
     }
-    function assertCanonicalSourcePacket(value, expectedPromptId, requireReady = true) {
+    var VERIFIED_CONTEXT_STATUSES = ["EXACT_SOURCE", "VERIFIED_FACT", "DERIVED"];
+    var UNVERIFIED_CONTEXT_AUTHORITIES = ["LEGACY_WEBSITE_EXACT", "AI_REWRITE_FROM_SOURCE"];
+    function verifiedContextAuthority(value, factualProvenance) {
+      if (!isObject(value) || !isObject(value.values) || !isObject(value.evidence))
+        throw new Error("SOURCE_PACKET_VERIFIED_CONTEXT_INVALID");
+      const provenance = factualProvenance === void 0 ? void 0 : factualProvenance;
+      if (provenance !== void 0 && !Array.isArray(provenance))
+        throw new Error("SOURCE_PACKET_FACTUAL_PROVENANCE_INVALID");
+      const eligibleProvenance = (Array.isArray(provenance) ? provenance : []).filter((entry) => isObject(entry) && VERIFIED_CONTEXT_STATUSES.includes(String(entry.status)) && typeof entry.source_authority === "string" && !UNVERIFIED_CONTEXT_AUTHORITIES.includes(entry.source_authority) && !(entry.source_authority === "DERIVED_DETERMINISTIC" && entry.requires_human_review === true) && Array.isArray(entry.source_refs));
+      const provenanceByField = new Map(eligibleProvenance.map((entry) => [String(entry.canonical_field), entry]));
+      const provenanceSourceRefs = new Set(eligibleProvenance.flatMap((entry) => entry.source_refs.map((ref) => JSON.stringify(canonicalize(ref)))));
+      const keys = /* @__PURE__ */ new Set();
+      for (const [key, rawEvidence] of Object.entries(value.evidence)) {
+        const rawValue = getPath(value.values, key);
+        if (rawValue === void 0 || !isObject(rawEvidence))
+          throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_ENTRY_INVALID:${key}`);
+        assertExactKeys(rawEvidence, ["value", "source_authority", "source_refs", "status"], `SOURCE_PACKET_VERIFIED_CONTEXT_ENTRY:${key}`);
+        if (JSON.stringify(canonicalize(rawEvidence.value)) !== JSON.stringify(canonicalize(rawValue)))
+          throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_VALUE_MISMATCH:${key}`);
+        if (!VERIFIED_CONTEXT_STATUSES.includes(String(rawEvidence.status)))
+          throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_STATUS_INVALID:${key}`);
+        if (typeof rawEvidence.source_authority !== "string" || UNVERIFIED_CONTEXT_AUTHORITIES.includes(rawEvidence.source_authority))
+          throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_AUTHORITY_INVALID:${key}`);
+        if (!Array.isArray(rawEvidence.source_refs) || rawEvidence.source_refs.length === 0 || rawEvidence.source_refs.some((ref) => !isObject(ref)))
+          throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_SOURCE_REFS_INVALID:${key}`);
+        if (provenance !== void 0) {
+          for (const ref of rawEvidence.source_refs)
+            if (!provenanceSourceRefs.has(JSON.stringify(canonicalize(ref))))
+              throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_SOURCE_REF_UNBOUND:${key}`);
+          const provenanceField = key.replace(/^coach_identity\.location\./, "coach.location.");
+          const direct = provenanceByField.get(provenanceField);
+          const requiresDirectProvenance = !key.startsWith("verified_context.") && !key.startsWith("coach_identity.location.");
+          if (requiresDirectProvenance && !direct)
+            throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_PROVENANCE_UNRESOLVED:${key}`);
+          if (direct) {
+            for (const member of ["value", "source_authority", "source_refs", "status"]) {
+              if (JSON.stringify(canonicalize(rawEvidence[member])) !== JSON.stringify(canonicalize(direct[member])))
+                throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_PROVENANCE_MISMATCH:${key}:${member}`);
+            }
+          }
+          if (key.startsWith("verified_context.")) {
+            const aggregateDomains = {
+              "verified_context.approved_career_facts": (entry) => String(entry.canonical_field).startsWith("about.stat_"),
+              "verified_context.verified_media": (entry) => String(entry.canonical_field).startsWith("about.media."),
+              "verified_context.approved_service_labels": (entry) => ["coach.title", "coach.service_area_heading", "coach.service_area_line"].includes(String(entry.canonical_field))
+            };
+            const inDomain = aggregateDomains[key];
+            if (!inDomain || rawEvidence.source_authority !== "DERIVED_DETERMINISTIC" || rawEvidence.status !== "DERIVED")
+              throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_AGGREGATE_AUTHORITY_INVALID:${key}`);
+            const records = key === "verified_context.approved_service_labels" ? ["coach.title", "coach.service_area_heading", "coach.service_area_line"].map((field) => provenanceByField.get(field)).filter((entry) => Boolean(entry)) : eligibleProvenance.filter(inDomain);
+            const expectedValue = records.map((entry) => ({ canonical_field: entry.canonical_field, value: entry.value }));
+            const expectedRefs = records.flatMap((entry) => entry.source_refs);
+            if (JSON.stringify(canonicalize(rawEvidence.value)) !== JSON.stringify(canonicalize(expectedValue)))
+              throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_AGGREGATE_VALUE_INVALID:${key}`);
+            if (JSON.stringify(canonicalize(rawEvidence.source_refs)) !== JSON.stringify(canonicalize(expectedRefs)))
+              throw new Error(`SOURCE_PACKET_VERIFIED_CONTEXT_AGGREGATE_REFS_INVALID:${key}`);
+          }
+        }
+        keys.add(key);
+      }
+      return { keys, values: value.values };
+    }
+    function sourceFieldAllowedForClass(definition, evidenceClass, canonicalField) {
+      if (evidenceClass === "FIELD_EVIDENCE" || evidenceClass === "PAGE_SECTION_EXCERPT")
+        return definition.sourcePolicy.groundingFieldAllowlist.includes(canonicalField);
+      if (evidenceClass === "DETERMINISTIC_FACT" || evidenceClass === "VERIFIED_FACTUAL_CONTEXT" || evidenceClass === "PRACTICE_CONTEXT")
+        return definition.sourcePolicy.factFieldAllowlist.includes(canonicalField);
+      return false;
+    }
+    function jobSourceFieldAllowed(definition, canonicalField) {
+      return definition.sourcePolicy.groundingFieldAllowlist.includes(canonicalField) || definition.sourcePolicy.factFieldAllowlist.includes(canonicalField);
+    }
+    function assertCanonicalSourcePacket(value, expectedPromptId, requireReady = true, verifiedFactualContext, factualProvenance) {
       assertExactKeys(value, PACKET_KEYS, "SOURCE_PACKET");
       const definition = promptDefinition(value.prompt_id);
       if (expectedPromptId && value.prompt_id !== expectedPromptId)
@@ -52966,13 +53443,22 @@ var require_contract = __commonJS({
         throw new Error("SOURCE_PACKET_EVIDENCE_STATUS_INVALID");
       if (requireReady && value.evidence_status !== "READY")
         throw new Error("SOURCE_PACKET_INSUFFICIENT_EVIDENCE");
-      if (!Array.isArray(value.source_evidence_references) || value.evidence_status === "READY" && value.source_evidence_references.length === 0)
+      if (!Array.isArray(value.source_evidence_references))
         throw new Error("SOURCE_PACKET_EVIDENCE_REQUIRED");
-      value.source_evidence_references.forEach((entry, index) => assertEvidence(entry, definition, index));
-      const covered = new Set(value.source_evidence_references.map((entry) => String(entry.canonical_field)));
-      const missing = definition.outputKeys.filter((key) => !covered.has(key));
-      if (value.evidence_status === "READY" && missing.length)
-        throw new Error(`SOURCE_PACKET_EVIDENCE_INCOMPLETE:${missing.join(",")}`);
+      const sourceReferences = /* @__PURE__ */ new Map();
+      value.source_evidence_references.forEach((entry, index) => {
+        assertEvidence(entry, index);
+        const reference = String(entry.evidence_reference);
+        if (sourceReferences.has(reference))
+          throw new Error(`SOURCE_EVIDENCE_${index}_DUPLICATE_ID`);
+        sourceReferences.set(reference, entry);
+      });
+      const contextAuthority = verifiedContextAuthority(verifiedFactualContext, factualProvenance);
+      const pool = assertEvidencePool(value.evidence_pool, definition, sourceReferences, contextAuthority);
+      assertGroundingRecords(value.grounding, definition, new Set(pool.pageEntries.keys()), new Set(pool.contextEntries.keys()), pool.relevanceByReference);
+      const unresolved = (Array.isArray(value.grounding) ? value.grounding : []).filter((record) => record.grounding_status === "NO_SUPPORTING_EVIDENCE" && String(record.grounding_basis).endsWith("UNRESOLVED_POLICY"));
+      if (value.evidence_status === "READY" && unresolved.length)
+        throw new Error(`SOURCE_PACKET_UNRESOLVED_POLICY:${unresolved.map((record) => String(record.canonical_field)).join(",")}`);
       const expectedText = value.source_evidence_references.map((entry) => entry.source_text).join("\n\n");
       if (value.source_text !== expectedText)
         throw new Error("SOURCE_PACKET_TEXT_INVALID");
@@ -52986,20 +53472,146 @@ var require_contract = __commonJS({
       if (digest !== sha256Canonical(digestInput))
         throw new Error("SOURCE_PACKET_DIGEST_INVALID");
     }
+    function assertGroundingRecords(grounding, definition, evidenceReferences, verifiedContextKeys, relevanceByReference) {
+      if (!Array.isArray(grounding) || grounding.length !== definition.outputKeys.length)
+        throw new Error("SOURCE_PACKET_GROUNDING_COUNT_INVALID");
+      const seen = /* @__PURE__ */ new Set();
+      grounding.forEach((raw) => {
+        assertExactKeys(raw, GROUNDING_RECORD_KEYS, "SOURCE_PACKET_GROUNDING");
+        const record = raw;
+        const field = String(record.canonical_field);
+        if (!definition.outputKeys.includes(field) || seen.has(field))
+          throw new Error(`SOURCE_PACKET_GROUNDING_FIELD_INVALID:${field}`);
+        seen.add(field);
+        const status = String(record.grounding_status);
+        if (!GROUNDING_STATUSES.includes(status))
+          throw new Error("SOURCE_PACKET_GROUNDING_STATUS_INVALID");
+        const refs = record.grounding_evidence_references;
+        if (!Array.isArray(refs) || refs.some((ref) => typeof ref !== "string" || !ref.trim()) || new Set(refs).size !== refs.length)
+          throw new Error("SOURCE_PACKET_GROUNDING_REFS_INVALID");
+        if (status === "GROUNDED" && refs.length === 0)
+          throw new Error("SOURCE_PACKET_GROUNDED_REQUIRES_REFERENCES");
+        if (status !== "GROUNDED" && refs.length)
+          throw new Error("SOURCE_PACKET_GROUNDING_REFS_UNEXPECTED");
+        for (const ref of refs) {
+          if (!evidenceReferences.has(ref) && !verifiedContextKeys.has(ref))
+            throw new Error(`SOURCE_PACKET_GROUNDING_REFERENCE_UNRESOLVED:${ref}`);
+          if (relevanceByReference) {
+            const destinationPolicy = definition.sourcePolicy.destinationGroundingMap[field];
+            const relevance = relevanceByReference.get(ref);
+            if (!destinationPolicy || !relevance || !destinationPolicy.relevant_relevance_classes.includes(relevance)) {
+              throw new Error(`SOURCE_PACKET_GROUNDING_RELEVANCE_INVALID:${field}:${ref}`);
+            }
+          }
+        }
+        if (typeof record.grounding_basis !== "string" || !record.grounding_basis.trim())
+          throw new Error("SOURCE_PACKET_GROUNDING_BASIS_INVALID");
+      });
+      for (const key of definition.outputKeys)
+        if (!seen.has(key))
+          throw new Error(`SOURCE_PACKET_GROUNDING_MISSING:${key}`);
+    }
+    function assertEvidencePool(pool, definition, sourceReferences, verifiedContext) {
+      if (!Array.isArray(pool))
+        throw new Error("SOURCE_PACKET_EVIDENCE_POOL_REQUIRED");
+      const pageAttributedClasses = ["FIELD_EVIDENCE", "PAGE_SECTION_EXCERPT", "DETERMINISTIC_FACT"];
+      const contextClasses = ["VERIFIED_FACTUAL_CONTEXT", "PRACTICE_CONTEXT"];
+      const pageEntries = /* @__PURE__ */ new Map();
+      const contextEntries = /* @__PURE__ */ new Map();
+      const relevanceByReference = /* @__PURE__ */ new Map();
+      for (const raw of pool) {
+        assertExactKeys(raw, ["evidence_reference", "evidence_class", "canonical_field", "page_url", "page_title", "source_locator", "source_text", "relevance_class"], "SOURCE_PACKET_EVIDENCE_POOL_ENTRY");
+        const entry = raw;
+        const reference = String(entry.evidence_reference ?? "");
+        if (!reference)
+          throw new Error("SOURCE_PACKET_EVIDENCE_REFERENCE_INVALID");
+        if (pageEntries.has(reference) || contextEntries.has(reference))
+          throw new Error(`SOURCE_PACKET_EVIDENCE_POOL_DUPLICATE_ID:${reference}`);
+        const evidenceClass = String(entry.evidence_class);
+        if (![...pageAttributedClasses, ...contextClasses].includes(evidenceClass))
+          throw new Error(`SOURCE_PACKET_EVIDENCE_CLASS_INVALID:${evidenceClass}`);
+        const canonicalField = String(entry.canonical_field ?? "");
+        if (!canonicalField || !sourceFieldAllowedForClass(definition, evidenceClass, canonicalField))
+          throw new Error(`SOURCE_PACKET_EVIDENCE_FIELD_INVALID:${evidenceClass}:${canonicalField}`);
+        const relevance = String(entry.relevance_class ?? "");
+        const authoritativeRelevance = definition.sourcePolicy.sourceFieldRelevanceMap[canonicalField];
+        if (!authoritativeRelevance || relevance !== authoritativeRelevance)
+          throw new Error(`SOURCE_PACKET_EVIDENCE_RELEVANCE_INVALID:${canonicalField}:${relevance}`);
+        if (pageAttributedClasses.includes(evidenceClass)) {
+          if (typeof entry.page_url !== "string" || !entry.page_url.trim() || typeof entry.page_title !== "string" || !entry.page_title.trim() || typeof entry.source_locator !== "string" || !entry.source_locator.trim())
+            throw new Error(`SOURCE_PACKET_EVIDENCE_PROVENANCE_INVALID:${evidenceClass}`);
+          const digestInput = { canonical_field: entry.canonical_field, page_url: entry.page_url, page_title: entry.page_title, source_locator: entry.source_locator, source_text: entry.source_text };
+          if (entry.evidence_reference !== sha256Canonical(digestInput))
+            throw new Error(`SOURCE_PACKET_EVIDENCE_DIGEST_INVALID:${String(entry.canonical_field)}`);
+          pageEntries.set(reference, entry);
+        } else {
+          if (entry.page_url !== null || entry.page_title !== null || entry.source_locator !== null)
+            throw new Error("SOURCE_PACKET_EVIDENCE_CONTEXT_PROVENANCE_UNEXPECTED");
+          if (entry.evidence_reference !== String(entry.canonical_field ?? ""))
+            throw new Error("SOURCE_PACKET_EVIDENCE_CONTEXT_KEY_INVALID");
+          if (!verifiedContext.keys.has(canonicalField))
+            throw new Error(`SOURCE_PACKET_EVIDENCE_CONTEXT_UNRESOLVED:${canonicalField}`);
+          const contextValue = getPath(verifiedContext.values, canonicalField);
+          if (entry.source_text !== JSON.stringify(canonicalize(contextValue)))
+            throw new Error(`SOURCE_PACKET_EVIDENCE_CONTEXT_PROJECTION_INVALID:${canonicalField}`);
+          contextEntries.set(reference, entry);
+        }
+        if (typeof entry.source_text !== "string" || !entry.source_text.trim())
+          throw new Error("SOURCE_PACKET_EVIDENCE_TEXT_REQUIRED");
+        if (entry.source_text.length > 2e3)
+          throw new Error("SOURCE_PACKET_EVIDENCE_EXCERPT_OVERBOUND");
+        relevanceByReference.set(reference, relevance);
+      }
+      if (pool.length > 48)
+        throw new Error("SOURCE_PACKET_EVIDENCE_POOL_OVERBOUND");
+      if (pageEntries.size !== sourceReferences.size)
+        throw new Error("SOURCE_PACKET_EVIDENCE_POOL_PROJECTION_COUNT_INVALID");
+      for (const [reference, source] of sourceReferences) {
+        const entry = pageEntries.get(reference);
+        if (!entry)
+          throw new Error(`SOURCE_PACKET_EVIDENCE_POOL_REFERENCE_UNRESOLVED:${reference}`);
+        for (const key of ["evidence_reference", "canonical_field", "page_url", "page_title", "source_locator", "source_text"]) {
+          if (entry[key] !== source[key])
+            throw new Error(`SOURCE_PACKET_EVIDENCE_PROJECTION_MISMATCH:${reference}:${key}`);
+        }
+      }
+      return { pageEntries, contextEntries, relevanceByReference };
+    }
+    function assertPreAiPackageOwnership(input, promptId) {
+      if (!isObject(input.pre_ai_package))
+        throw new Error("BOUNDARY_PRE_AI_PACKAGE_MUST_BE_OBJECT");
+      const { package_digest: packageDigest, ...packageBody } = input.pre_ai_package;
+      if (typeof packageDigest !== "string" || packageDigest !== sha256Canonical(packageBody))
+        throw new Error("BOUNDARY_PRE_AI_PACKAGE_DIGEST_INVALID");
+      if (!Array.isArray(packageBody.aiSourcePackets))
+        throw new Error("BOUNDARY_PRE_AI_PACKAGE_PACKETS_INVALID");
+      const ownedPacket = packageBody.aiSourcePackets.find((packet) => isObject(packet) && packet.prompt_id === promptId && JSON.stringify(canonicalize(packet)) === JSON.stringify(canonicalize(input.source_packet)));
+      if (!ownedPacket)
+        throw new Error(`BOUNDARY_SOURCE_PACKET_NOT_OWNED_BY_PRE_AI_PACKAGE:${promptId}`);
+      if (JSON.stringify(canonicalize(packageBody.verifiedFactualContext)) !== JSON.stringify(canonicalize(input.verified_factual_context))) {
+        throw new Error("BOUNDARY_VERIFIED_CONTEXT_NOT_OWNED_BY_PRE_AI_PACKAGE");
+      }
+      return packageBody;
+    }
     function buildBoundedNarrativeJob(input) {
-      assertExactKeys(input, ["contract_id", "prompt_id", "source_packet", "verified_factual_context", "required_output_schema"], "BOUNDARY_INPUT");
+      assertExactKeys(input, ["contract_id", "prompt_id", "source_packet", "verified_factual_context", "pre_ai_package", "required_output_schema", "template_baseline"], "BOUNDARY_INPUT");
       if (input.contract_id !== exports2.CONTRACT_ID)
         throw new Error("BOUNDED_AI_CONTRACT_ID_INVALID");
       const definition = promptDefinition(input.prompt_id);
       const promptId = input.prompt_id;
-      assertCanonicalSourcePacket(input.source_packet, promptId);
-      const expectedSchema = requiredOutputSchemaForPrompt(promptId);
+      const owningPackage = assertPreAiPackageOwnership(input, promptId);
+      assertCanonicalSourcePacket(input.source_packet, promptId, true, input.verified_factual_context, owningPackage.factualProvenance);
+      const packet = input.source_packet;
+      if (!isObject(input.verified_factual_context))
+        throw new Error("BOUNDED_AI_VERIFIED_CONTEXT_INVALID");
+      const expectedSchema = effectiveOutputSchemaForPrompt(promptId, Array.isArray(packet.grounding) ? packet.grounding : []);
       if (JSON.stringify(canonicalize(input.required_output_schema)) !== JSON.stringify(canonicalize(expectedSchema)))
         throw new Error("BOUNDED_AI_OUTPUT_SCHEMA_INVALID");
-      if (!isObject(input.verified_factual_context))
+      const contextSource = input.verified_factual_context;
+      if (!isObject(contextSource))
         throw new Error("BOUNDED_AI_VERIFIED_CONTEXT_INVALID");
-      const values = isObject(input.verified_factual_context.values) ? input.verified_factual_context.values : {};
-      const evidence = isObject(input.verified_factual_context.evidence) ? input.verified_factual_context.evidence : {};
+      const values = isObject(contextSource.values) ? contextSource.values : {};
+      const evidence = isObject(contextSource.evidence) ? contextSource.evidence : {};
       const filteredContext = {};
       for (const key of definition.allowedContextKeys) {
         const rawEvidence = evidence[key];
@@ -53008,7 +53620,7 @@ var require_contract = __commonJS({
           continue;
         filteredContext[key] = { value: structuredClone(rawValue), evidence_refs: [...new Set(rawEvidence.source_refs.map((ref) => sha256Canonical(ref)))].sort() };
       }
-      const packet = input.source_packet;
+      const templateBaseline = assertTemplateBaseline(input.template_baseline);
       const job = {
         prompt_id: promptId,
         source_text: String(packet.source_text),
@@ -53017,30 +53629,87 @@ var require_contract = __commonJS({
         required_output_schema: structuredClone(expectedSchema),
         source_locators: structuredClone(packet.source_locators),
         source_packet_digest: String(packet.source_packet_digest),
-        contract_version: exports2.CONTRACT_VERSION
+        contract_version: exports2.CONTRACT_VERSION,
+        grounding: structuredClone(packet.grounding),
+        template_baseline: templateBaseline
       };
       assertBoundedJob(job);
       return job;
     }
+    function assertTemplateBaseline(value) {
+      assertExactKeys(value, TEMPLATE_BASELINE_KEYS, "TEMPLATE_BASELINE");
+      const baseline = value;
+      if (typeof baseline.manifest_digest !== "string" || !/^[0-9a-f]{64}$/.test(baseline.manifest_digest))
+        throw new Error("TEMPLATE_BASELINE_DIGEST_INVALID");
+      if (typeof baseline.manifest_version !== "string" || !baseline.manifest_version.trim())
+        throw new Error("TEMPLATE_BASELINE_VERSION_INVALID");
+      if (!Array.isArray(baseline.elements) || baseline.elements.length === 0)
+        throw new Error("TEMPLATE_BASELINE_ELEMENTS_REQUIRED");
+      for (const raw of baseline.elements) {
+        assertExactKeys(raw, TEMPLATE_BASELINE_ELEMENT_KEYS, "TEMPLATE_BASELINE_ELEMENT");
+        const element = raw;
+        if (typeof element.captured_content !== "string" || !element.captured_content.trim())
+          throw new Error("TEMPLATE_BASELINE_ELEMENT_CONTENT_REQUIRED");
+        if (typeof element.content_sha256 !== "string" || element.content_sha256 !== (0, node_crypto_1.createHash)("sha256").update(String(element.captured_content), "utf8").digest("hex")) {
+          throw new Error("TEMPLATE_BASELINE_ELEMENT_DIGEST_INVALID");
+        }
+        if (/POC-T\d/i.test(String(element.captured_content)))
+          throw new Error("TEMPLATE_BASELINE_POC_RENDER_VALUE_REJECTED");
+      }
+      return structuredClone(value);
+    }
     function assertBoundedJob(value) {
       assertExactKeys(value, JOB_KEYS, "BOUNDED_AI_JOB");
       const definition = promptDefinition(value.prompt_id);
       if (value.contract_version !== exports2.CONTRACT_VERSION)
         throw new Error("BOUNDED_AI_CONTRACT_VERSION_INVALID");
-      if (typeof value.source_text !== "string" || !value.source_text.trim())
+      if (typeof value.source_text !== "string")
         throw new Error("BOUNDED_AI_SOURCE_TEXT_REQUIRED");
-      if (!Array.isArray(value.source_evidence) || value.source_evidence.length === 0)
+      if (!Array.isArray(value.source_evidence))
         throw new Error("BOUNDED_AI_SOURCE_EVIDENCE_REQUIRED");
-      value.source_evidence.forEach((entry, index) => assertEvidence(entry, definition, index));
-      if (!Array.isArray(value.source_locators) || value.source_locators.some((entry) => typeof entry !== "string") || new Set(value.source_locators).size !== value.source_locators.length)
-        throw new Error("BOUNDED_AI_SOURCE_LOCATORS_INVALID");
+      if (value.source_evidence.length > 0) {
+        const seenEvidence = /* @__PURE__ */ new Set();
+        value.source_evidence.forEach((entry, index) => {
+          assertEvidence(entry, index);
+          if (!jobSourceFieldAllowed(definition, String(entry.canonical_field)))
+            throw new Error(`SOURCE_EVIDENCE_${index}_FIELD_INVALID`);
+          const reference = String(entry.evidence_reference);
+          if (seenEvidence.has(reference))
+            throw new Error(`SOURCE_EVIDENCE_${index}_DUPLICATE_ID`);
+          seenEvidence.add(reference);
+        });
+        if (typeof value.source_text !== "string" || !value.source_text.trim())
+          throw new Error("BOUNDED_AI_SOURCE_TEXT_REQUIRED");
+        if (!Array.isArray(value.source_locators) || value.source_locators.some((entry) => typeof entry !== "string") || new Set(value.source_locators).size !== value.source_locators.length)
+          throw new Error("BOUNDED_AI_SOURCE_LOCATORS_INVALID");
+        const expectedText = value.source_evidence.map((entry) => entry.source_text).join("\n\n");
+        if (value.source_text !== expectedText)
+          throw new Error("BOUNDED_AI_SOURCE_TEXT_INVALID");
+        const expectedLocators = [...new Set(value.source_evidence.map((entry) => `${String(entry.page_url)}#${String(entry.source_locator)}`))].sort();
+        if (JSON.stringify(value.source_locators) !== JSON.stringify(expectedLocators))
+          throw new Error("BOUNDED_AI_SOURCE_LOCATORS_INVALID");
+      } else {
+        if (value.source_text !== "")
+          throw new Error("BOUNDED_AI_SOURCE_TEXT_INVALID");
+        if (!Array.isArray(value.source_locators) || value.source_locators.length !== 0)
+          throw new Error("BOUNDED_AI_SOURCE_LOCATORS_INVALID");
+      }
       if (!DIGEST.test(String(value.source_packet_digest)))
         throw new Error("BOUNDED_AI_PACKET_DIGEST_INVALID");
       if (!isObject(value.verified_factual_context) || Object.keys(value.verified_factual_context).some((key) => !definition.allowedContextKeys.includes(key)))
         throw new Error("BOUNDED_AI_VERIFIED_CONTEXT_INVALID");
-      if (JSON.stringify(canonicalize(value.required_output_schema)) !== JSON.stringify(canonicalize(requiredOutputSchemaForPrompt(value.prompt_id))))
+      if (!Array.isArray(value.grounding))
+        throw new Error("BOUNDED_AI_GROUNDING_REQUIRED");
+      assertGroundingRecords(value.grounding, definition, evidenceReferenceSet(value.source_evidence), new Set(Object.keys(value.verified_factual_context)));
+      if (typeof value.template_baseline !== "object" || value.template_baseline === null)
+        throw new Error("TEMPLATE_BASELINE_REQUIRED");
+      assertTemplateBaseline(value.template_baseline);
+      if (JSON.stringify(canonicalize(value.required_output_schema)) !== JSON.stringify(canonicalize(effectiveOutputSchemaForPrompt(value.prompt_id, value.grounding))))
         throw new Error("BOUNDED_AI_OUTPUT_SCHEMA_INVALID");
     }
+    function evidenceReferenceSet(sourceEvidence) {
+      return new Set(sourceEvidence.map((entry) => String(entry.evidence_reference ?? "")));
+    }
     function validateOutput(value, format, field, issues) {
       if (typeof value !== "string" || !value.trim()) {
         issues.push(`${field}:NON_EMPTY_STRING_REQUIRED`);
@@ -53089,15 +53758,23 @@ var require_contract = __commonJS({
       issues.push(...[...new Set(formatIssues)].map((issue) => `${field}:HTML_FRAGMENT_INVALID:${issue}`));
     }
     function validateFactMarkers(outputs, job, issues) {
-      const grounding = JSON.stringify(canonicalize({ source_text: job.source_text, verified_factual_context: job.verified_factual_context })).toLowerCase();
-      const patterns = [/https?:\/\/[^\s<>'"]+/gi, /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, /(?:[$€£]\s?\d[\d,.]*|\b\d[\d,.]*\s?(?:%|percent|years?|clients?|businesses?|locations?|awards?|certifications?)\b)/gi, /\b(?:guaranteed?|award[- ]winning|certified|licensed|available 24\/7|speciali[sz](?:e|es|ed|ing) in)\b/gi];
+      const coachCorpus = JSON.stringify(canonicalize({ source_text: job.source_text, verified_factual_context: job.verified_factual_context })).toLowerCase();
+      const templateCorpus = JSON.stringify(canonicalize(job.template_baseline.elements ?? [])).toLowerCase();
+      const personBoundPatterns = [/https?:\/\/[^\s<>'"]+/gi, /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, /(?:[$€£]\s?\d[\d,.]*|\b\d[\d,.]*\s?(?:%|percent|years?|clients?|businesses?|locations?|awards?|certifications?)\b)/gi, /\b[A-Z][a-z]+\s+[A-Z][a-z]+\b/g];
+      const genericClaimPatterns = [/\b(?:guaranteed?|award[- ]winning|certified|licensed|available 24\/7|speciali[sz](?:e|es|ed|ing) in)\b/gi];
       for (const [field, raw] of Object.entries(outputs)) {
         if (typeof raw !== "string")
           continue;
-        for (const pattern of patterns)
+        for (const pattern of personBoundPatterns)
           for (const match of raw.matchAll(pattern))
-            if (!grounding.includes(match[0].toLowerCase().replace(/[.,;:!?]+$/, "")))
+            if (!coachCorpus.includes(match[0].toLowerCase().replace(/[.,;:!?]+$/, "")))
+              issues.push(`${field}:UNSUPPORTED_FACT_MARKER:${match[0]}`);
+        for (const pattern of genericClaimPatterns)
+          for (const match of raw.matchAll(pattern)) {
+            const marker = match[0].toLowerCase();
+            if (!coachCorpus.includes(marker) && !templateCorpus.includes(marker))
               issues.push(`${field}:UNSUPPORTED_FACT_MARKER:${match[0]}`);
+          }
       }
     }
     function validateNarrativeResponse(value, job) {
@@ -53122,18 +53799,23 @@ var require_contract = __commonJS({
         issues.push("OUTPUTS_INVALID");
       if (!Array.isArray(value.provenance))
         issues.push("PROVENANCE_INVALID");
+      const effectiveKeys = effectiveOutputKeys(job.prompt_id, job.grounding);
+      const omittedKeys = new Set(conditionallyOmittedKeysFromGrounding(job.prompt_id, job.grounding));
       if (value.status === "OK" && isObject(value.outputs) && Array.isArray(value.provenance)) {
         try {
-          assertExactKeys(value.outputs, definition.outputKeys, "OUTPUTS");
+          assertExactKeys(value.outputs, effectiveKeys, "OUTPUTS");
         } catch (error) {
           issues.push(error instanceof Error ? error.message : String(error));
         }
-        for (const key of definition.outputKeys)
+        for (const key of omittedKeys)
+          if (key in value.outputs)
+            issues.push(`CONDITIONALLY_OMITTED_OUTPUT_PRESENT:${key}`);
+        for (const key of effectiveKeys)
           validateOutput(value.outputs[key], definition.formats[key], key, issues);
         validateFactMarkers(value.outputs, job, issues);
         if (!Array.isArray(value.errors) || value.errors.length)
           issues.push("OK_ERRORS_MUST_BE_EMPTY");
-        if (value.provenance.length !== definition.outputKeys.length)
+        if (value.provenance.length !== effectiveKeys.length)
           issues.push("PROVENANCE_COUNT_INVALID");
         const seen = /* @__PURE__ */ new Set();
         for (const [index, raw] of value.provenance.entries()) {
@@ -53144,23 +53826,34 @@ var require_contract = __commonJS({
             continue;
           }
           const field = String(raw.canonical_field);
-          if (!definition.outputKeys.includes(field) || seen.has(field))
+          if (!effectiveKeys.includes(field) || seen.has(field))
             issues.push(`PROVENANCE_${index}_FIELD_INVALID`);
           else
             seen.add(field);
-          const allowedRefs = new Set(job.source_evidence.filter((entry) => entry.canonical_field === field).map((entry) => String(entry.evidence_reference)));
-          if (!Array.isArray(raw.source_refs) || raw.source_refs.length === 0 || raw.source_refs.some((ref) => typeof ref !== "string" || !allowedRefs.has(ref)))
+          const groundingRecord = job.grounding.find((record) => record.canonical_field === field);
+          const groundingRefs = new Set(groundingRecord?.grounding_evidence_references ?? []);
+          const requestEvidenceRefs = new Set(job.source_evidence.map((entry) => String(entry.evidence_reference)));
+          const authorizedEvidenceRefs = new Set([...groundingRefs].filter((ref) => requestEvidenceRefs.has(ref)));
+          const authorizedContextRefs = new Set([...groundingRefs].filter((ref) => Object.hasOwn(job.verified_factual_context, ref)));
+          if (!Array.isArray(raw.source_refs) || raw.source_refs.some((ref) => typeof ref !== "string" || !authorizedEvidenceRefs.has(ref)) || new Set(raw.source_refs).size !== raw.source_refs.length)
             issues.push(`PROVENANCE_${index}_SOURCE_REFS_INVALID`);
-          if (!Array.isArray(raw.verified_context_refs) || raw.verified_context_refs.some((ref) => typeof ref !== "string" || !Object.hasOwn(job.verified_factual_context, ref)))
+          if (!Array.isArray(raw.verified_context_refs) || raw.verified_context_refs.some((ref) => typeof ref !== "string" || !authorizedContextRefs.has(ref)) || new Set(raw.verified_context_refs).size !== raw.verified_context_refs.length)
             issues.push(`PROVENANCE_${index}_CONTEXT_REFS_INVALID`);
+          if (groundingRecord?.grounding_status === "GROUNDED" && Array.isArray(raw.source_refs) && raw.source_refs.length === 0 && Array.isArray(raw.verified_context_refs) && raw.verified_context_refs.length === 0)
+            issues.push(`PROVENANCE_${index}_NO_GROUNDING`);
         }
-        for (const key of definition.outputKeys)
+        for (const key of effectiveKeys)
           if (!seen.has(key))
             issues.push(`PROVENANCE_MISSING:${key}`);
         for (const key of definition.exactCopyKeys) {
+          if (!effectiveKeys.includes(key))
+            continue;
           const output = value.outputs[key];
-          const matches = job.source_evidence.filter((entry) => entry.canonical_field === key).some((entry) => String(entry.source_text).replace(/\s+/g, " ").trim() === String(output).replace(/\s+/g, " ").trim());
-          if (!matches)
+          const groundingRecord = job.grounding.find((record) => record.canonical_field === key);
+          const groundingRefs = new Set(groundingRecord?.grounding_evidence_references ?? []);
+          const evidenceMatch = job.source_evidence.filter((entry) => groundingRefs.has(String(entry.evidence_reference))).some((entry) => String(entry.source_text).replace(/\s+/g, " ").trim() === String(output).replace(/\s+/g, " ").trim());
+          const baselineMatch = (job.template_baseline.elements ?? []).some((element) => String(element.captured_content).replace(/\s+/g, " ").trim() === String(output).replace(/\s+/g, " ").trim());
+          if (!evidenceMatch && !baselineMatch)
             issues.push(`${key}:EXACT_COPY_MISMATCH`);
         }
       } else if (statuses.includes(String(value.status))) {
@@ -53215,6 +53908,10 @@ var require_pre_ai_contract = __commonJS({
       "status",
       "factualCanonicalValues",
       "factualProvenance",
+      "missingRequiredFacts",
+      "reviewRequiredFacts",
+      "requiredVerifiedAuthorityFacts",
+      "manualFinalizationFacts",
       "rawPageEvidenceIssues",
       "manualApprovedCandidates",
       "mediaCandidates",
@@ -53232,6 +53929,8 @@ var require_pre_ai_contract = __commonJS({
       "package_digest"
     ];
     var FINAL_NARRATIVE_KEYS = new Set(contract_1.ALL_OUTPUT_KEYS);
+    var MANUAL_FINALIZATION_FACT_KEYS = ["canonical_field", "disposition", "reason"];
+    var MANUAL_FINALIZATION_DISPOSITIONS = ["MANUAL_GHL_FINALIZATION"];
     function exactKeys(value) {
       const actual = Object.keys(value);
       const missing = PRE_AI_KEYS.filter((key) => !actual.includes(key));
@@ -53260,6 +53959,25 @@ var require_pre_ai_contract = __commonJS({
       }
       return null;
     }
+    function assertManualFinalizationFacts(value) {
+      if (!Array.isArray(value))
+        throw new Error("PRE_AI_PACKAGE_MANUAL_FINALIZATION_FACTS_INVALID");
+      for (const entry of value) {
+        if (!(0, contract_1.isObject)(entry))
+          throw new Error("PRE_AI_PACKAGE_MANUAL_FINALIZATION_FACT_INVALID");
+        const actual = Object.keys(entry);
+        const missing = MANUAL_FINALIZATION_FACT_KEYS.filter((key) => !actual.includes(key));
+        const extra = actual.filter((key) => !MANUAL_FINALIZATION_FACT_KEYS.includes(key));
+        if (missing.length || extra.length)
+          throw new Error(`PRE_AI_PACKAGE_MANUAL_FINALIZATION_FACT_INVALID:missing=${missing.join(",")}:extra=${extra.join(",")}`);
+        if (typeof entry.canonical_field !== "string" || !entry.canonical_field.trim())
+          throw new Error("PRE_AI_PACKAGE_MANUAL_FINALIZATION_FIELD_INVALID");
+        if (typeof entry.reason !== "string" || !entry.reason.trim())
+          throw new Error("PRE_AI_PACKAGE_MANUAL_FINALIZATION_REASON_INVALID");
+        if (!MANUAL_FINALIZATION_DISPOSITIONS.includes(String(entry.disposition)))
+          throw new Error("PRE_AI_PACKAGE_MANUAL_FINALIZATION_DISPOSITION_INVALID");
+      }
+    }
     function validatePreAiPackage(value) {
       if (!(0, contract_1.isObject)(value))
         throw new Error("PRE_AI_PACKAGE_MUST_BE_OBJECT");
@@ -53272,23 +53990,33 @@ var require_pre_ai_contract = __commonJS({
         throw new Error("PRE_AI_PACKAGE_AI_CONTRACT_INVALID");
       if (!["PRE_AI_READY", "PRE_AI_BLOCKED"].includes(String(value.status)))
         throw new Error("PRE_AI_PACKAGE_STATUS_INVALID");
+      if (!(0, contract_1.isObject)(value.verifiedFactualContext) || !(0, contract_1.isObject)(value.verifiedFactualContext.values) || !(0, contract_1.isObject)(value.verifiedFactualContext.evidence))
+        throw new Error("PRE_AI_PACKAGE_VERIFIED_CONTEXT_INVALID");
       if (!Array.isArray(value.aiSourcePackets) || value.aiSourcePackets.length !== 6)
         throw new Error("PRE_AI_PACKAGE_PACKET_COUNT_INVALID");
       const seenPrompts = /* @__PURE__ */ new Set();
       for (const packet of value.aiSourcePackets) {
-        (0, contract_1.assertCanonicalSourcePacket)(packet, void 0, false);
+        (0, contract_1.assertCanonicalSourcePacket)(packet, void 0, false, value.verifiedFactualContext, value.factualProvenance);
         seenPrompts.add(String(packet.prompt_id));
       }
       if (seenPrompts.size !== 6 || contract_1.PROMPT_IDS.some((promptId) => !seenPrompts.has(promptId)))
         throw new Error("PRE_AI_PACKAGE_PROMPT_SET_INVALID");
-      if (!Array.isArray(value.pendingNarrativeFields) || JSON.stringify(value.pendingNarrativeFields) !== JSON.stringify(contract_1.ALL_OUTPUT_KEYS))
+      if (!Array.isArray(value.pendingNarrativeFields))
+        throw new Error("PRE_AI_PACKAGE_PENDING_NARRATIVES_INVALID");
+      const industries = Array.isArray(value.conditionalSectionStates) ? value.conditionalSectionStates.find((state) => state.group === "INDUSTRIES_GROUP") : void 0;
+      const populated = Number(industries?.populated_fields ?? 0);
+      const expectedPending = populated > 0 ? contract_1.ALL_OUTPUT_KEYS : contract_1.ALL_OUTPUT_KEYS.filter((key) => key !== "about.industries.heading");
+      if (JSON.stringify(value.pendingNarrativeFields) !== JSON.stringify(expectedPending))
         throw new Error("PRE_AI_PACKAGE_PENDING_NARRATIVES_INVALID");
+      for (const key of ["missingRequiredFacts", "reviewRequiredFacts", "requiredVerifiedAuthorityFacts"]) {
+        if (!Array.isArray(value[key]) || value[key].some((entry) => typeof entry !== "string" || !entry.trim()))
+          throw new Error(`PRE_AI_PACKAGE_UNRESOLVED_FACT_STATE_INVALID:${key}`);
+      }
+      assertManualFinalizationFacts(value.manualFinalizationFacts);
       if (!Array.isArray(value.testimonialCandidates) || value.testimonialCandidates.length !== 12)
         throw new Error("PRE_AI_PACKAGE_TESTIMONIAL_COUNT_INVALID");
       if (!(0, contract_1.isObject)(value.frozenCountEvidence) || value.frozenCountEvidence.canonical_fields !== 76 || value.frozenCountEvidence.active_custom_values !== 67 || value.frozenCountEvidence.automated_ai_prompt_groups !== 6 || value.frozenCountEvidence.automated_ai_output_fields !== 17)
         throw new Error("PRE_AI_PACKAGE_FROZEN_COUNTS_INVALID");
-      if (!(0, contract_1.isObject)(value.verifiedFactualContext) || !(0, contract_1.isObject)(value.verifiedFactualContext.values) || !(0, contract_1.isObject)(value.verifiedFactualContext.evidence))
-        throw new Error("PRE_AI_PACKAGE_VERIFIED_CONTEXT_INVALID");
       const narrativePath = containsFinalNarrative(value.factualCanonicalValues);
       if (narrativePath)
         throw new Error(`PRE_AI_PACKAGE_FINAL_NARRATIVE_PRESENT:${narrativePath}`);
@@ -53310,7 +54038,7 @@ var require_extract_pre_ai_package = __commonJS({
     var pieces_common_1 = require_src4();
     var output_schemas_1 = require_output_schemas();
     var pre_ai_contract_1 = require_pre_ai_contract();
-    var PRIVATE_RUNTIME_URL = "http://172.25.0.6:3010/extract/pre-ai";
+    var PRIVATE_RUNTIME_URL = "http://coach-migration-runtime:3010/extract/pre-ai";
     exports2.extractPreAiPackage = (0, pieces_framework_12.createAction)({
       name: "extract_pre_ai_package",
       displayName: "Extract Canonical PREAI Package",
@@ -53350,8 +54078,9 @@ var require_transform_narrative_job = __commonJS({
     var pieces_framework_12 = require_src2();
     var pieces_common_1 = require_src4();
     var contract_1 = require_contract();
+    var pre_ai_contract_1 = require_pre_ai_contract();
     var output_schemas_1 = require_output_schemas();
-    var PRIVATE_RUNTIME_URL = "http://172.25.0.6:3010/narrative/transform";
+    var PRIVATE_RUNTIME_URL = "http://coach-migration-runtime:3010/narrative/transform";
     exports2.transformNarrativeJob = (0, pieces_framework_12.createAction)({
       name: "transform_narrative_job",
       displayName: "Transform Bounded Narrative Job",
@@ -53376,12 +54105,15 @@ var require_transform_narrative_job = __commonJS({
           options: { disabled: false, options: contract_1.PROMPT_IDS.map((value) => ({ label: value, value })) }
         }),
         source_packet: pieces_framework_12.Property.Json({ displayName: "Canonical Source Packet", description: "Exactly one packet from Extract Canonical PREAI Package.", required: true }),
-        verified_factual_context: pieces_framework_12.Property.Json({ displayName: "Verified Factual Context", description: "The verifiedFactualContext object from the same PREAI package. It is filtered to the prompt allowlist.", required: true }),
-        required_output_schema: pieces_framework_12.Property.Json({ displayName: "Required Output Schema", description: "Frozen schema for the selected prompt; must match the contract exactly.", required: true })
+        verified_factual_context: pieces_framework_12.Property.Json({ displayName: "Verified Factual Context", description: "The verifiedFactualContext object from the same PREAI package. It is filtered to the prompt allowlist and enforced as owned by the supplied PREAI package (B-1).", required: true }),
+        pre_ai_package: pieces_framework_12.Property.Json({ displayName: "Owning PREAI Package", description: "The full PREAI package from the same Extract Canonical PREAI Package run as the source packet; its package_digest is the ownership identity binding the packet, verified factual context, and factual provenance (B-1).", required: true }),
+        required_output_schema: pieces_framework_12.Property.Json({ displayName: "Required Output Schema", description: "Effective schema for the selected prompt; must match the contract-derived effective set exactly.", required: true }),
+        template_baseline: pieces_framework_12.Property.Json({ displayName: "Template Narrative Baseline", description: "Verified FOCALPOINT_STANDARD template FORM baseline with its manifest digest; form authority only, never factual source.", required: true })
       },
       outputSchema: output_schemas_1.transformNarrativeJobOutputSchema,
       run: async (context) => {
-        const job = (0, contract_1.buildBoundedNarrativeJob)(context.propsValue);
+        const validatedPackage = (0, pre_ai_contract_1.validatePreAiPackage)(context.propsValue.pre_ai_package);
+        const job = (0, contract_1.buildBoundedNarrativeJob)({ ...context.propsValue, pre_ai_package: validatedPackage });
         try {
           const response = await pieces_common_1.httpClient.sendRequest({
             method: pieces_common_1.HttpMethod.POST,