@mindflight/mindbrain-personal-studio 0.6.2 → 0.6.4

package/examples/immeuble/scripts/enrich-immeuble-demo.mjs

@@ -0,0 +1,1135 @@
+#!/usr/bin/env node
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const WS = "immeuble";
+const ONT = "immeuble::core";
+const GENERATED_TAG = "portfolio_v2";
+const GENERATED_MIN_ID = 2000;
+const GENERATED_REL_MIN_ID = 10000;
+const NOW = 1760000000;
+
+const paths = {
+  bundle: join(ROOT, "bundle", "immeuble.bundle.json"),
+  projectionCatalog: join(ROOT, "contracts", "projection_catalog.yaml"),
+  answerSeed: join(ROOT, "contracts", "answer_artifacts.seed.jsonl"),
+  businessSeed: join(ROOT, "contracts", "business_capabilities.seed.jsonl"),
+  consumerContract: join(ROOT, "contracts", "consumer_contract.yaml"),
+  acceptance: join(ROOT, "ACCEPTANCE.yaml"),
+  successCriteria: join(ROOT, "success-criteria.yaml"),
+  gapRules: join(ROOT, "gap-rules"),
+  docs: join(ROOT, "sources", "documents")
+};
+
+function meta(value = {}) {
+  return JSON.stringify({ ...value, generated_by: GENERATED_TAG });
+}
+
+function parseMeta(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function slug(value) {
+  return String(value)
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .replace(/_+/g, "_");
+}
+
+function yamlScalar(value) {
+  if (value == null) return "";
+  const text = String(value);
+  if (/^[A-Za-z0-9_.:/-]+$/.test(text)) return text;
+  return JSON.stringify(text);
+}
+
+function yamlList(values) {
+  return `[${values.map((value) => yamlScalar(value)).join(", ")}]`;
+}
+
+function entity(id, type, name, metadata = {}) {
+  return {
+    workspace_id: WS,
+    ontology_id: ONT,
+    entity_id: id,
+    entity_type: type,
+    name,
+    confidence: 1,
+    metadata_json: meta(metadata)
+  };
+}
+
+function relation(id, edge, source, target, metadata = {}) {
+  return {
+    workspace_id: WS,
+    ontology_id: ONT,
+    relation_id: id,
+    edge_type: edge,
+    source_entity_id: source,
+    target_entity_id: target,
+    valid_from: null,
+    valid_to: null,
+    confidence: 1,
+    metadata_json: meta(metadata)
+  };
+}
+
+function doc(id, title, content, documentType, domain = "syndic") {
+  const source = `examples/immeuble/sources/documents/generated-${slug(title)}.md`;
+  return {
+    workspace_id: WS,
+    collection_id: "immeuble::docs",
+    doc_id: id,
+    doc_nanoid: `immeuble-doc-${id}`,
+    content,
+    language: "fr",
+    source_ref: source,
+    summary: title,
+    metadata_json: meta({ title, document_type: documentType, domain, synthetic: true })
+  };
+}
+
+function chunkFor(document) {
+  return {
+    workspace_id: WS,
+    collection_id: document.collection_id,
+    doc_id: document.doc_id,
+    chunk_index: 0,
+    content: document.content,
+    language: document.language,
+    offset_start: 0,
+    offset_end: document.content.length,
+    strategy: "document",
+    token_count: Math.max(20, Math.ceil(document.content.length / 5)),
+    parent_chunk_index: null,
+    metadata_json: document.metadata_json
+  };
+}
+
+function artifact(kind, name, label, payload, lifecycle = "stale", state = "dirty", legacyRef = null) {
+  const prefix = kind === "analysis_plan" ? "analysis_plan" : kind;
+  return {
+    artifact_id: `${prefix}__${name}`,
+    slug: name,
+    workspace_id: WS,
+    agent_id: kind === "analysis_plan" ? "agent:immeuble" : null,
+    scope: kind === "analysis_plan" ? WS : null,
+    artifact_kind: kind,
+    public_label_key: `${kind}.immeuble.${name}`,
+    public_label: label,
+    lifecycle,
+    state,
+    current_version: 1,
+    payload_json: JSON.stringify(payload),
+    legacy_ref: legacyRef,
+    created_at_unix: NOW,
+    updated_at_unix: NOW
+  };
+}
+
+function addType(bundle, type, label = type, layer = "operations") {
+  bundle.ontology_entity_types ??= [];
+  if (!bundle.ontology_entity_types.some((row) => row.entity_type === type)) {
+    bundle.ontology_entity_types.push({
+      ontology_id: ONT,
+      entity_type: type,
+      label,
+      metadata_json: JSON.stringify({
+        linkml_class: type,
+        abstract: false,
+        ghostcrab: {
+          "ghostcrab.native_entity_type": type,
+          "ghostcrab.layer": layer
+        },
+        generated_by: GENERATED_TAG
+      })
+    });
+  }
+}
+
+function addEdgeType(bundle, edge, source, target) {
+  bundle.ontology_edge_types ??= [];
+  if (!bundle.ontology_edge_types.some((row) => row.edge_type === edge && row.source_entity_type === source && row.target_entity_type === target)) {
+    bundle.ontology_edge_types.push({
+      ontology_id: ONT,
+      edge_type: edge,
+      directed: true,
+      source_entity_type: source,
+      target_entity_type: target,
+      metadata_json: meta({ source_entity_type: source, target_entity_type: target })
+    });
+  }
+}
+
+function addEntityDocument(bundle, entityId, docId, role = "evidence") {
+  bundle.entity_documents_raw.push({
+    workspace_id: WS,
+    entity_id: entityId,
+    collection_id: "immeuble::docs",
+    doc_id: docId,
+    role,
+    confidence: 0.9
+  });
+  bundle.entity_chunks_raw.push({
+    workspace_id: WS,
+    entity_id: entityId,
+    collection_id: "immeuble::docs",
+    doc_id: docId,
+    chunk_index: 0,
+    role,
+    confidence: 0.9
+  });
+}
+
+function nextFactory(start) {
+  let current = start;
+  return () => current++;
+}
+
+function buildPortfolioData(bundle) {
+  const nextEntity = nextFactory(GENERATED_MIN_ID);
+  const nextRel = nextFactory(GENERATED_REL_MIN_ID);
+  const nextDoc = nextFactory(100);
+  const entities = [];
+  const relations = [];
+  const docs = [];
+  const entityDocs = [];
+  const aliases = [];
+
+  const generatedBuildings = [
+    { name: "Residence Les Platanes", address: "4 avenue des Platanes, 1300 Wavre", city: "Wavre" },
+    { name: "Residence Le Canal", address: "18 quai du Canal, 1000 Bruxelles", city: "Bruxelles" },
+    { name: "Residence Saint-Lambert", address: "7 rue Saint-Lambert, 4000 Liege", city: "Liege" }
+  ];
+  const quotaSets = [
+    [120, 110, 115, 105, 120, 110, 115, 105, 100],
+    [115, 115, 110, 110, 115, 115, 110, 110, 100],
+    [125, 105, 120, 100, 125, 105, 120, 100, 100]
+  ];
+  const firstNames = ["Anne", "Karim", "Lucie", "Noah", "Maya", "Thomas", "Sofia", "Hugo", "Lina", "Nora", "Elias", "Eva"];
+  const lastNames = ["Mercier", "Simon", "Lambert", "Petit", "Dubois", "Nguyen", "Rossi", "Peeters", "Colin", "Jacobs"];
+
+  for (const [buildingIndex, buildingInput] of generatedBuildings.entries()) {
+    const buildingId = nextEntity();
+    const building = entity(buildingId, "building", buildingInput.name, {
+      address: buildingInput.address,
+      city: buildingInput.city,
+      quota_basis: 1000,
+      portfolio_segment: "medium_demo"
+    });
+    entities.push(building);
+
+    const acpId = nextEntity();
+    entities.push(entity(acpId, "organization", `ACP ${buildingInput.name}`, {
+      role: "association_coproprietaires",
+      building_id: buildingId
+    }));
+    relations.push(relation(nextRel(), "represents", acpId, buildingId, { role: "acp" }));
+    relations.push(relation(nextRel(), "manages", 201, buildingId, { role: "syndic_reference" }));
+
+    const buildingDoc = doc(
+      nextDoc(),
+      `Registre operationnel ${buildingInput.name}`,
+      `${buildingInput.name} est ajoutee au portefeuille demo avec blocs, lots, coproprietaires, charges, contrats, releves et anomalies pedagogiques.`,
+      "registre_operationnel"
+    );
+    docs.push(buildingDoc);
+    entityDocs.push([buildingId, buildingDoc.doc_id, "portfolio_register"]);
+
+    const blockIds = [];
+    for (const blockName of ["A", "B"]) {
+      const blockId = nextEntity();
+      blockIds.push(blockId);
+      entities.push(entity(blockId, "block", `${buildingInput.name} Bloc ${blockName}`, {
+        building_id: buildingId,
+        building: buildingInput.name,
+        block: blockName
+      }));
+      relations.push(relation(nextRel(), "contains", buildingId, blockId, { level: "block" }));
+    }
+
+    const sharedSpaceId = nextEntity();
+    const equipmentId = nextEntity();
+    const meterId = nextEntity();
+    entities.push(entity(sharedSpaceId, "shared_space", `${buildingInput.name} Local technique`, {
+      building_id: buildingId,
+      usage: "technical_room"
+    }));
+    entities.push(entity(equipmentId, "shared_equipment", `${buildingInput.name} Chaufferie collective`, {
+      building_id: buildingId,
+      equipment_type: "heating",
+      status: buildingIndex === 1 ? "maintenance_due" : "active"
+    }));
+    entities.push(entity(meterId, "meter", `${buildingInput.name} Compteur eau general`, {
+      building_id: buildingId,
+      meter_type: "water",
+      serial: `EAU-${buildingId}`
+    }));
+    relations.push(relation(nextRel(), "contains", buildingId, sharedSpaceId, { level: "shared_space" }));
+    relations.push(relation(nextRel(), "contains", sharedSpaceId, equipmentId, { level: "equipment" }));
+    relations.push(relation(nextRel(), "measures_asset", meterId, buildingId, { meter_type: "water" }));
+
+    const contractId = nextEntity();
+    const contractorId = nextEntity();
+    entities.push(entity(contractorId, "organization", `Maintenance ${buildingInput.city} Services`, {
+      role: "maintenance_provider",
+      city: buildingInput.city
+    }));
+    entities.push(entity(contractId, "service_contract", `Contrat maintenance ${buildingInput.name}`, {
+      building_id: buildingId,
+      starts_on: "2026-01-01",
+      expires_on: buildingIndex === 0 ? "2026-05-31" : "2026-12-31",
+      status: buildingIndex === 0 ? "renewal_due" : "active"
+    }));
+    relations.push(relation(nextRel(), "covers_asset", contractId, equipmentId, { scope: "technical_equipment" }));
+    if (buildingIndex !== 2) {
+      relations.push(relation(nextRel(), "provided_by", contractId, contractorId, { role: "maintenance_provider" }));
+    }
+
+    const policyId = nextEntity();
+    entities.push(entity(policyId, "insurance_policy", `Police assurance ${buildingInput.name}`, {
+      building_id: buildingId,
+      policy_ref: `POL-${buildingId}-2026`,
+      status: buildingIndex === 2 ? "missing_annex" : "active"
+    }));
+    relations.push(relation(nextRel(), "covers_asset", policyId, buildingId, { scope: "building" }));
+
+    for (let unitIndex = 0; unitIndex < 9; unitIndex++) {
+      const local = unitIndex + 1;
+      const unitId = nextEntity();
+      const cellarId = nextEntity();
+      const billingId = nextEntity();
+      const householdId = nextEntity();
+      const ownerId = nextEntity();
+      const occupantId = nextEntity();
+      const blockId = blockIds[unitIndex < 5 ? 0 : 1];
+      const lot = `${unitIndex < 5 ? "A" : "B"}${local}`;
+      const status =
+        unitIndex % 5 === 0 ? "tenant_occupied" :
+        unitIndex % 7 === 0 ? "vacant_works" :
+        "owner_occupied";
+      const unitName = `${buildingInput.name} Appartement ${lot}`;
+      const ownerName = `${firstNames[(buildingIndex * 3 + unitIndex) % firstNames.length]} ${lastNames[(buildingIndex + unitIndex) % lastNames.length]}`;
+      const occupantName = status === "tenant_occupied"
+        ? `${firstNames[(buildingIndex * 5 + unitIndex + 4) % firstNames.length]} ${lastNames[(buildingIndex * 2 + unitIndex + 3) % lastNames.length]}`
+        : ownerName;
+
+      entities.push(entity(unitId, "unit", unitName, {
+        building_id: buildingId,
+        building: buildingInput.name,
+        block_id: blockId,
+        block: unitIndex < 5 ? "A" : "B",
+        floor: Math.floor(unitIndex / 2),
+        lot,
+        door_label: `${lot}-2026`,
+        bedrooms: 1 + (unitIndex % 3),
+        tantiemes: quotaSets[buildingIndex][unitIndex],
+        quota_basis: 1000,
+        usage_status: status
+      }));
+      entities.push(entity(cellarId, "cellar", `${buildingInput.name} Cave ${lot}`, {
+        building_id: buildingId,
+        lot
+      }));
+      entities.push(entity(billingId, "billing_group", `Groupe facturation ${buildingInput.name} ${lot}`, {
+        unit_id: unitId,
+        status: unitIndex === 4 ? "missing_recipient" : "active"
+      }));
+      entities.push(entity(householdId, "household", `Menage ${occupantName} ${lot}`, {
+        unit_id: unitId,
+        household_type: status === "tenant_occupied" ? "tenant" : "owner"
+      }));
+      entities.push(entity(ownerId, "person", ownerName, {
+        role: "coproprietaire",
+        age_band: unitIndex % 3 === 0 ? "45-64" : "25-44"
+      }));
+      entities.push(entity(occupantId, "person", occupantName, {
+        role: status === "tenant_occupied" ? "locataire" : "occupant_proprietaire",
+        age_band: "25-44"
+      }));
+
+      relations.push(relation(nextRel(), "contains", buildingId, unitId, { level: "unit" }));
+      relations.push(relation(nextRel(), "contains", blockId, unitId, { level: "unit" }));
+      relations.push(relation(nextRel(), "contains", buildingId, cellarId, { level: "cellar" }));
+      if (!(buildingIndex === 0 && unitIndex === 6)) {
+        relations.push(relation(nextRel(), "assigned_cellar", unitId, cellarId, { lot }));
+      }
+      if (!(buildingIndex === 1 && unitIndex === 2)) {
+        relations.push(relation(nextRel(), "owns", ownerId, unitId, { share: 1 }));
+      }
+      if (!(buildingIndex === 2 && unitIndex === 3)) {
+        relations.push(relation(nextRel(), "occupies", occupantId, unitId, { status }));
+        relations.push(relation(nextRel(), "household_member", householdId, occupantId, { role: "occupant" }));
+      }
+      relations.push(relation(nextRel(), "primary_residence_of", unitId, householdId, { status }));
+      if (!(buildingIndex === 1 && unitIndex === 4)) {
+        relations.push(relation(nextRel(), "bills_to", billingId, unitId, { mode: "charges" }));
+      }
+      relations.push(relation(nextRel(), "has_member", billingId, ownerId, { role: "recipient" }));
+
+      if (status === "tenant_occupied") {
+        const leaseId = nextEntity();
+        entities.push(entity(leaseId, "lease_contract", `Bail ${unitName}`, {
+          unit_id: unitId,
+          validFrom: "2025-09-01",
+          validTo: unitIndex === 0 ? "2026-08-31" : "2028-08-31",
+          monthly_rent: 780 + unitIndex * 25,
+          status: "active"
+        }));
+        if (!(buildingIndex === 2 && unitIndex === 0)) {
+          relations.push(relation(nextRel(), "leases", leaseId, unitId, { status: "active" }));
+        }
+        relations.push(relation(nextRel(), "rented_to", leaseId, householdId, { status: "active" }));
+      }
+
+      for (const period of ["2026-01", "2026-02"]) {
+        const amount = 280 + unitIndex * 11 + buildingIndex * 30;
+        const chargeId = nextEntity();
+        entities.push(entity(chargeId, "charge_call", `Appel charges ${buildingInput.name} ${lot} ${period}`, {
+          unit_id: unitId,
+          period,
+          amount,
+          currency: "EUR",
+          status: period === "2026-02" && unitIndex % 4 === 0 ? "open" : "issued"
+        }));
+        relations.push(relation(nextRel(), "bills_to", chargeId, billingId, { period }));
+        if (!(period === "2026-02" && unitIndex % 4 === 0)) {
+          const codaId = nextEntity();
+          entities.push(entity(codaId, "coda_entry", `CODA ${buildingInput.name} ${lot} ${period}`, {
+            amount,
+            currency: "EUR",
+            communication: `${lot} ${period}`,
+            status: unitIndex === 8 ? "manual_review" : "matched"
+          }));
+          relations.push(relation(nextRel(), "matched_to", codaId, chargeId, { period }));
+          relations.push(relation(nextRel(), "allocated_to", codaId, billingId, { period }));
+        } else {
+          const reminderId = nextEntity();
+          entities.push(entity(reminderId, "reminder", `Relance ${buildingInput.name} ${lot} ${period}`, {
+            level: 1,
+            amount_due: amount,
+            currency: "EUR",
+            status: buildingIndex === 0 ? "missing_send_proof" : "draft"
+          }));
+          if (buildingIndex !== 0) {
+            relations.push(relation(nextRel(), "triggered", chargeId, reminderId, { reason: "open_charge" }));
+          }
+        }
+      }
+    }
+
+    for (let readingIndex = 0; readingIndex < 6; readingIndex++) {
+      const readingId = nextEntity();
+      entities.push(entity(readingId, "meter_reading", `${buildingInput.name} releve eau ${readingIndex + 1}`, {
+        meter_id: meterId,
+        reading_date: `2026-0${readingIndex + 1}-28`,
+        value_m3: 1000 + buildingIndex * 200 + readingIndex * 18,
+        status: readingIndex === 5 && buildingIndex === 1 ? "missing_validation" : "validated"
+      }));
+      relations.push(relation(nextRel(), "records_reading", meterId, readingId, { cadence: "monthly" }));
+    }
+
+    for (let ticketIndex = 0; ticketIndex < 4; ticketIndex++) {
+      const ticketId = nextEntity();
+      const interventionId = nextEntity();
+      entities.push(entity(ticketId, "maintenance_ticket", `${buildingInput.name} ticket maintenance ${ticketIndex + 1}`, {
+        building_id: buildingId,
+        priority: ticketIndex === 0 ? "high" : "normal",
+        status: ticketIndex === 3 ? "late" : "open"
+      }));
+      entities.push(entity(interventionId, "intervention", `${buildingInput.name} intervention ${ticketIndex + 1}`, {
+        planned_on: `2026-04-${10 + ticketIndex}`,
+        status: ticketIndex === 2 && buildingIndex === 1 ? "provider_missing" : "planned"
+      }));
+      relations.push(relation(nextRel(), "concerns_asset", ticketId, ticketIndex % 2 === 0 ? equipmentId : sharedSpaceId, { origin: "resident_report" }));
+      relations.push(relation(nextRel(), "has_intervention", ticketId, interventionId, { status: "planned" }));
+      if (!(ticketIndex === 2 && buildingIndex === 1)) {
+        relations.push(relation(nextRel(), "provided_by", interventionId, contractorId, { role: "field_operator" }));
+      }
+    }
+
+    const claimId = nextEntity();
+    entities.push(entity(claimId, "claim", `Sinistre infiltration ${buildingInput.name}`, {
+      building_id: buildingId,
+      status: buildingIndex === 2 ? "missing_policy_link" : "open",
+      declared_on: "2026-03-18"
+    }));
+    relations.push(relation(nextRel(), "concerns_asset", claimId, buildingId, { damage: "water" }));
+    if (buildingIndex !== 2) {
+      relations.push(relation(nextRel(), "covered_by", claimId, policyId, { claim_status: "declared" }));
+    }
+
+    for (const cert of ["electricite", "incendie", "ascenseur"]) {
+      const certId = nextEntity();
+      entities.push(entity(certId, "compliance_certificate", `${buildingInput.name} certificat ${cert}`, {
+        building_id: buildingId,
+        certificate_type: cert,
+        expires_on: cert === "incendie" && buildingIndex === 0 ? "2026-02-15" : "2027-12-31",
+        status: cert === "incendie" && buildingIndex === 0 ? "expired" : "valid"
+      }));
+      if (!(cert === "ascenseur" && buildingIndex === 1)) {
+        relations.push(relation(nextRel(), "certifies_asset", certId, buildingId, { certificate_type: cert }));
+      }
+    }
+
+    const agId = nextEntity();
+    const agendaId = nextEntity();
+    const decisionId = nextEntity();
+    entities.push(entity(agId, "ag_meeting", `AG ordinaire ${buildingInput.name} 2026`, {
+      held_on: "2026-05-20",
+      status: "scheduled"
+    }));
+    entities.push(entity(agendaId, "agenda_item", `Point AG maintenance ${buildingInput.name}`, {
+      topic: "maintenance",
+      status: buildingIndex === 2 ? "without_decision" : "open"
+    }));
+    entities.push(entity(decisionId, "decision", `Decision maintenance ${buildingInput.name}`, {
+      date: "2026-05-20",
+      status: buildingIndex === 2 ? "missing_action" : "approved"
+    }));
+    relations.push(relation(nextRel(), "has_agenda_item", agId, agendaId, { order: 3 }));
+    if (buildingIndex !== 2) {
+      relations.push(relation(nextRel(), "decided_by", agendaId, decisionId, { status: "approved" }));
+    }
+    relations.push(relation(nextRel(), "concerns_asset", agendaId, buildingId, { topic: "maintenance" }));
+  }
+
+  const extraWorksiteId = nextEntity();
+  const extraArchitectId = nextEntity();
+  const extraPackageId = nextEntity();
+  const extraContractorId = nextEntity();
+  const extraPermitId = nextEntity();
+  const extraInvoiceId = nextEntity();
+  const extraBudgetId = nextEntity();
+  const extraInspectionId = nextEntity();
+  const extraReserveId = nextEntity();
+  entities.push(entity(extraWorksiteId, "worksite_project", "Chantier Platanes ventilation parking", {
+    status: "active",
+    phase: "preparation",
+    planned_start: "2026-06-01",
+    planned_end: "2026-09-30",
+    profile: "construction_lite"
+  }));
+  entities.push(entity(extraArchitectId, "architect", "Nadia Claes", { role: "architecte_responsable", registration: "A-BE-2201" }));
+  entities.push(entity(extraPackageId, "work_package", "Lot ventilation parking Platanes", { discipline: "ventilation", status: "planned", planned_budget_eur: 41000 }));
+  entities.push(entity(extraContractorId, "contractor", "Ventibel Techniques", { specialty: "ventilation", approval: "classe_2" }));
+  entities.push(entity(extraPermitId, "permit", "Autorisation ventilation Platanes", { issued_on: "2026-05-05", expires_on: "2027-05-05" }));
+  entities.push(entity(extraBudgetId, "budget_line", "Budget ventilation Platanes", { approved_amount_eur: 39000, forecast_amount_eur: 41000, status: "over_forecast" }));
+  entities.push(entity(extraInvoiceId, "invoice", "Facture acompte ventilation Platanes", { amount_eur: 15000, status: "received" }));
+  entities.push(entity(extraInspectionId, "inspection", "Inspection ventilation Platanes", { date: "2026-06-15", result: "reserve" }));
+  entities.push(entity(extraReserveId, "defect_reserve", "Reserve gaine coupe-feu parking", { severity: "error", status: "open", due_date: "2026-06-30" }));
+  relations.push(relation(nextRel(), "manages_project", 201, extraWorksiteId, { role: "syndic" }));
+  relations.push(relation(nextRel(), "designs_for", extraArchitectId, extraWorksiteId, { appointment: "architecte_responsable" }));
+  relations.push(relation(nextRel(), "has_work_package", extraWorksiteId, extraPackageId, { order: 1 }));
+  relations.push(relation(nextRel(), "executes_work_package", extraContractorId, extraPackageId, { contract_ref: "VENT-2026-001" }));
+  relations.push(relation(nextRel(), "authorized_by", extraWorksiteId, extraPermitId, { permit_scope: "ventilation" }));
+  relations.push(relation(nextRel(), "has_budget_line", extraWorksiteId, extraBudgetId, { approved_by: "AG-2026-PLATANES" }));
+  relations.push(relation(nextRel(), "invoiced_by", extraPackageId, extraInvoiceId, { invoice_type: "acompte" }));
+  relations.push(relation(nextRel(), "affects_asset", extraPackageId, 2002, { asset_scope: "parking" }));
+  relations.push(relation(nextRel(), "has_reserve", extraInspectionId, extraReserveId, { reserve_status: "open" }));
+
+  const allEntityIds = new Set([...bundle.entities_raw, ...entities].map((row) => Number(row.entity_id)));
+  const projectionDefinitions = buildProjectionDefinitions();
+  for (const projection of projectionDefinitions.snapshots) {
+    const id = nextEntity();
+    entities.push(entity(id, "ProjectionResult", projection.label, {
+      projection_id: projection.name,
+      collection_id: WS,
+      metric: projection.metric,
+      summary: projection.summary
+    }));
+    const evidenceId = allEntityIds.has(Number(projection.evidenceId)) ? projection.evidenceId : 1000;
+    relations.push(relation(nextRel(), "evidenced_by", id, evidenceId, { projection_id: projection.name }));
+  }
+
+  for (const finding of buildDeltaFindings()) {
+    const id = nextEntity();
+    entities.push(entity(id, "DeltaFinding", finding.label, {
+      finding_id: finding.id,
+      rule_id: finding.rule_id,
+      severity: finding.severity,
+      expected: finding.expected,
+      observed: finding.observed,
+      procedure_id: finding.procedure_id,
+      status: "open"
+    }));
+    if (finding.entityId && allEntityIds.has(Number(finding.entityId))) {
+      relations.push(relation(nextRel(), "flags_entity", id, finding.entityId, { rule_id: finding.rule_id }));
+    }
+  }
+
+  const operationalDocs = [
+    ["Procedure controle proprietaires", "Chaque lot actif doit avoir un proprietaire et un groupe de facturation. Les exceptions sont les lots communs et les lots neutralises.", "procedure_syndic"],
+    ["Procedure rapprochement CODA", "Les virements CODA sont rapproches aux appels de charges. Les lignes inconnues et paiements partiels partent en revue.", "procedure_finance"],
+    ["Procedure relances impayes", "Les appels ouverts apres echeance declenchent une relance avec preuve d'envoi.", "procedure_finance"],
+    ["Procedure AG decisions", "Chaque point d'ordre du jour approuve doit produire une decision et une action de suivi.", "procedure_gouvernance"],
+    ["Procedure contrats maintenance", "Un contrat de maintenance actif doit couvrir chaque equipement technique critique et nommer un prestataire.", "procedure_exploitation"],
+    ["Procedure interventions", "Chaque ticket de maintenance doit avoir une intervention planifiee puis un prestataire.", "procedure_maintenance"],
+    ["Procedure certificats", "Les certificats electricite, incendie et ascenseur doivent rester valides et lies aux assets.", "procedure_conformite"],
+    ["Procedure sinistres", "Chaque sinistre doit etre relie a une police et a une preuve documentaire.", "procedure_sinistre"],
+    ["Procedure chantier permis", "Chaque chantier actif doit avoir un architecte, au moins un lot de travaux, un permis et un budget.", "procedure_chantier"],
+    ["Procedure reception reserves", "Chaque reserve de reception doit etre reliee a une inspection et une preuve documentaire.", "procedure_chantier"]
+  ];
+  for (const [title, content, type] of operationalDocs) {
+    docs.push(doc(nextDoc(), title, content, type));
+  }
+
+  bundle.entities_raw.push(...entities);
+  bundle.relations_raw.push(...relations);
+  for (const document of docs) {
+    bundle.documents_raw.push(document);
+    bundle.chunks_raw.push(chunkFor(document));
+  }
+  for (const [entityId, docId, role] of entityDocs) addEntityDocument(bundle, entityId, docId, role);
+  for (const e of entities) {
+    if (["building", "unit", "worksite_project", "maintenance_ticket", "claim", "service_contract"].includes(e.entity_type)) {
+      aliases.push({ workspace_id: WS, entity_id: e.entity_id, term: e.name, confidence: 0.95 });
+    }
+  }
+  bundle.entity_aliases_raw.push(...aliases);
+}
+
+function buildProjectionDefinitions() {
+  const live = [
+    ["annuaire_coproprietes", "Annuaire immeubles geres", "Quels immeubles sont geres et ou sont-ils situes ?", ["building", "block"], ["CONTAINS"], "procedure_portefeuille"],
+    ["lots_sans_proprietaire", "Lots sans proprietaire", "Quels lots actifs n'ont pas de proprietaire declare ?", ["unit", "person"], ["OWNS"], "procedure_proprietaires"],
+    ["occupants_sans_titre", "Occupants sans titre", "Quels lots sont occupes sans occupant, bail ou residence principale coherente ?", ["unit", "person", "household", "lease_contract"], ["OCCUPIES", "LEASES", "PRIMARY_RESIDENCE_OF"], "procedure_occupation"],
+    ["baux_actifs", "Baux locatifs actifs", "Quels appartements sont loues, a qui, depuis quelle date et par quel bailleur ?", ["unit", "lease_contract", "person"], ["LEASES", "RENTED_TO", "OCCUPIES"], "procedure_baux"],
+    ["baux_echeance_90j", "Baux a echeance 90 jours", "Quels baux arrivent a echeance dans les 90 prochains jours ?", ["lease_contract", "unit"], ["LEASES"], "procedure_baux"],
+    ["quotites_par_immeuble", "Quotites par immeuble", "Les quotites de chaque immeuble totalisent-elles 1000 ?", ["building", "unit"], ["CONTAINS"], "procedure_quotites"],
+    ["annexes_par_lot", "Annexes par lot", "Quelle cave, garage ou jardin est rattache a chaque lot ?", ["unit", "cellar", "parking_space", "private_garden"], ["ASSIGNED_CELLAR", "ASSIGNED_GARAGE", "USES_EXCLUSIVE"], "procedure_annexes"],
+    ["appels_charges_ouverts", "Appels de charges ouverts", "Quels appels de charges restent ouverts ou partiellement payes ?", ["charge_call", "billing_group"], ["BILLS_TO"], "procedure_finance"],
+    ["coda_a_rapprocher", "CODA a rapprocher", "Quelles lignes CODA doivent etre investiguees ?", ["coda_entry", "charge_call"], ["MATCHED_TO", "REQUIRES_REVIEW"], "procedure_coda"],
+    ["relances_a_lancer", "Relances a lancer", "Quelles relances doivent etre envoyees aujourd'hui ?", ["charge_call", "reminder"], ["TRIGGERED"], "procedure_relances"],
+    ["soldes_coproprietaires", "Soldes coproprietaires", "Quels coproprietaires ont des impayes ou relances actives ?", ["person", "unit", "charge_call", "reminder"], ["OWNS", "BILLS_TO", "TRIGGERED"], "procedure_finance"],
+    ["decisions_ag_a_executer", "Decisions AG a executer", "Quelles decisions AG attendent une action de suivi ?", ["ag_meeting", "agenda_item", "decision"], ["HAS_AGENDA_ITEM", "DECIDED_BY"], "procedure_ag"],
+    ["documents_obligatoires_manquants", "Documents obligatoires manquants", "Quels documents obligatoires manquent par immeuble ou procedure ?", ["document", "building"], ["EVIDENCED_BY"], "procedure_documents"],
+    ["contrats_maintenance_echeance", "Contrats maintenance a echeance", "Quels contrats de maintenance expirent ou n'ont pas de prestataire ?", ["service_contract", "organization", "shared_equipment"], ["COVERS_ASSET", "PROVIDED_BY"], "procedure_maintenance"],
+    ["interventions_en_retard", "Interventions en retard", "Quelles interventions sont en retard ou sans prestataire ?", ["maintenance_ticket", "intervention", "organization"], ["HAS_INTERVENTION", "PROVIDED_BY"], "procedure_interventions"],
+    ["certificats_conformite", "Certificats conformite", "Quels certificats sont expires, manquants ou non relies a un asset ?", ["compliance_certificate", "building"], ["CERTIFIES_ASSET"], "procedure_conformite"],
+    ["sinistres_ouverts", "Sinistres ouverts", "Quels sinistres sont ouverts et quelles preuves ou polices manquent ?", ["claim", "insurance_policy", "document"], ["COVERED_BY", "EVIDENCED_BY"], "procedure_sinistres"],
+    ["compteurs_releves", "Compteurs et releves", "Quels compteurs ont des releves manquants ou non valides ?", ["meter", "meter_reading"], ["RECORDS_READING"], "procedure_compteurs"],
+    ["chantier_actif", "Chantier actif", "Quel est l'etat des chantiers actifs et qui en est responsable ?", ["worksite_project", "architect", "contractor", "work_package"], ["MANAGES_PROJECT", "DESIGNS_FOR", "HAS_WORK_PACKAGE", "EXECUTES_WORK_PACKAGE"], "procedure_chantier"],
+    ["planning_chantier", "Planning chantier", "Quels jalons chantier sont en retard ou ouverts ?", ["worksite_project", "milestone", "progress_event"], ["HAS_MILESTONE"], "procedure_chantier"],
+    ["budget_travaux", "Budget travaux", "Le budget travaux vote couvre-t-il les devis, factures et avenants ?", ["budget_line", "quote", "invoice", "change_order"], ["HAS_BUDGET_LINE", "BASED_ON_QUOTE", "INVOICED_BY"], "procedure_chantier"],
+    ["lots_impactes", "Lots et espaces impactes", "Quels batiments, blocs, lots ou espaces sont impactes par les travaux ?", ["work_package", "building", "block", "unit", "shared_space"], ["AFFECTS_ASSET"], "procedure_chantier"],
+    ["permis_reglementaires", "Permis et pieces reglementaires", "Quelles pieces reglementaires autorisent le chantier ?", ["permit", "worksite_project", "document"], ["AUTHORIZED_BY", "EVIDENCED_BY"], "procedure_chantier"],
+    ["reserves_reception", "Reserves de reception", "Quelles reserves restent ouvertes apres inspection ?", ["inspection", "defect_reserve", "document"], ["HAS_RESERVE", "REPORTED_BY", "EVIDENCED_BY"], "procedure_chantier"],
+    ["priorites_gestionnaire", "Priorites gestionnaire", "Quelles 3 a 5 actions doivent remonter au gestionnaire aujourd'hui ?", ["DeltaFinding", "maintenance_ticket", "charge_call"], ["FLAGS_ENTITY"], "procedure_priorites"]
+  ].map(([name, label, question, schemas, edges, procedureId]) => ({
+    name,
+    label,
+    description: question,
+    business_question: question,
+    artifact_kind: "live_answer_view",
+    scope: `immeuble:operations:${name}`,
+    procedure_id: procedureId,
+    procedure_area: procedureId.replace("procedure_", ""),
+    required_schemas: schemas,
+    required_facets: schemas.map((schema) => `${schema}.name`),
+    required_edges: edges,
+    gap_rule_ids: [],
+    retrieval_jobs: ["summary", "graph_focus"],
+    expected_output: "Tableau operationnel avec entites sources, anomalies ouvertes et action conseillee."
+  }));
+
+  const snapshots = [
+    ["portfolio_health", "Sante portefeuille", "portfolio_health", "Vue consolidee portefeuille, charges, maintenance et conformite.", 2000],
+    ["owner_gaps", "Trous proprietaires", "owner_gap_count", "Lots sans proprietaire ou occupant detectes.", 2018],
+    ["finance_risk", "Risque finance", "open_finance_risk", "Appels ouverts, relances et CODA a rapprocher.", 2020],
+    ["maintenance_backlog", "Backlog maintenance", "maintenance_backlog", "Tickets en retard et prestataires manquants.", 2030],
+    ["compliance_risk", "Risque conformite", "compliance_risk", "Certificats expires ou non rattaches.", 2040],
+    ["claims_open", "Sinistres ouverts", "claims_open", "Sinistres sans police ou preuve documentaire.", 2050],
+    ["chantier_erables_synthese", "Synthese chantier Erables", "worksite_summary", "Chantier Erables avec budget, planning et reserves.", 1000],
+    ["chantier_platanes_budget", "Budget chantier Platanes", "worksite_budget", "Ventilation parking Platanes au-dessus du budget vote.", 2447]
+  ].map(([name, label, metric, summary, evidenceId]) => ({ name, label, metric, summary, evidenceId }));
+
+  return { live, snapshots };
+}
+
+function buildDeltaFindings() {
+  return [
+    ["df_unit_owner_missing", "Lot sans proprietaire", "unit-has-owner", "error", "1 owner", "0 owner", "procedure_proprietaires", 2062],
+    ["df_unit_occupant_missing", "Lot occupe sans occupant", "occupied-unit-has-occupant", "error", "1 occupant", "0 occupant", "procedure_occupation", 2127],
+    ["df_lease_missing", "Lot loue sans bail lie", "tenant-occupied-has-lease", "warning", "1 lease", "0 lease", "procedure_baux", 2391],
+    ["df_billing_missing", "Lot sans groupe facturation", "billing-group-bills-unit", "warning", "1 billing group", "0 billing group", "procedure_finance", 2099],
+    ["df_cellar_missing", "Cave non assignee", "unit-one-cellar", "error", "1 cellar", "0 cellar", "procedure_annexes", 2092],
+    ["df_coda_unknown", "CODA en revue manuelle", "coda-entry-reviewed", "warning", "matched or reviewed", "manual_review", "procedure_coda", 2123],
+    ["df_reminder_missing", "Relance sans preuve", "open-charge-has-reminder", "warning", "sent reminder", "missing_send_proof", "procedure_relances", 2085],
+    ["df_ag_action_missing", "Decision AG sans action", "agenda-item-has-decision", "warning", "decision/action", "missing_action", "procedure_ag", 2444],
+    ["df_contract_provider_missing", "Contrat sans prestataire", "service-contract-has-provider", "error", "provider", "0 provider", "procedure_maintenance", 2278],
+    ["df_intervention_provider_missing", "Intervention sans prestataire", "intervention-has-provider", "warning", "provider", "0 provider", "procedure_interventions", 2288],
+    ["df_certificate_expired", "Certificat incendie expire", "certificate-valid", "error", "valid certificate", "expired", "procedure_conformite", 2080],
+    ["df_claim_policy_missing", "Sinistre sans police", "claim-covered-by-policy", "error", "policy link", "0 policy", "procedure_sinistres", 2441],
+    ["df_worksite_budget_over", "Budget chantier depasse", "worksite-has-budget-line", "warning", "forecast <= approved", "forecast > approved", "procedure_chantier", 2453],
+    ["df_invoice_budget_missing", "Facture chantier sans budget", "invoice-linked-to-work-package", "warning", "work package link", "partial link only", "procedure_chantier", 2454],
+    ["df_reserve_open", "Reserve reception ouverte", "reserve-linked-to-inspection", "error", "closed reserve", "open", "procedure_chantier", 2457],
+    ["df_meter_reading_unvalidated", "Releve compteur non valide", "meter-has-recent-reading", "warning", "validated", "missing_validation", "procedure_compteurs", 2296]
+  ].map(([id, label, rule_id, severity, expected, observed, procedure_id, entityId]) => ({
+    id, label, rule_id, severity, expected, observed, procedure_id, entityId
+  }));
+}
+
+function buildProjectionCatalog() {
+  const { live } = buildProjectionDefinitions();
+  const allQuestions = live.map((entry) => ({
+    id: entry.procedure_id,
+    title: entry.label,
+    competency_question: entry.business_question
+  }));
+  const entries = [
+    {
+      name: "immeuble_competency_questions",
+      label: "Plan d'analyse immeuble - questions operationnelles",
+      business_question: "Quelles procedures operationnelles le workspace immeuble doit-il couvrir ?",
+      description: "Quelles procedures operationnelles le workspace immeuble doit-il couvrir ?",
+      artifact_kind: "analysis_plan",
+      scope: "immeuble:competency:questions",
+      procedure_id: "procedure_catalogue",
+      procedure_area: "pilotage",
+      required_schemas: ["building", "unit", "charge_call", "maintenance_ticket", "worksite_project"],
+      required_facets: ["building.name", "unit.usage_status", "charge_call.status"],
+      required_edges: ["CONTAINS", "OWNS", "BILLS_TO", "HAS_WORK_PACKAGE"],
+      retrieval_jobs: ["summary"],
+      expected_output: "Catalogue des questions et projections attendues.",
+      competency_questions: allQuestions
+    },
+    ...live
+  ];
+  const lines = ["workspace_id: immeuble", "projections:"];
+  for (const entry of entries) {
+    lines.push(`  - name: ${entry.name}`);
+    lines.push(`    label: ${yamlScalar(entry.label)}`);
+    lines.push(`    description: ${yamlScalar(entry.description)}`);
+    lines.push(`    business_question: ${yamlScalar(entry.business_question)}`);
+    lines.push(`    artifact_kind: ${entry.artifact_kind}`);
+    lines.push(`    scope: ${entry.scope}`);
+    lines.push(`    procedure_id: ${entry.procedure_id}`);
+    lines.push(`    procedure_area: ${entry.procedure_area}`);
+    lines.push(`    expected_output: ${yamlScalar(entry.expected_output)}`);
+    lines.push(`    required_schemas: ${yamlList(entry.required_schemas)}`);
+    lines.push(`    required_facets: ${yamlList(entry.required_facets)}`);
+    lines.push(`    required_edges: ${yamlList(entry.required_edges)}`);
+    lines.push(`    gap_rule_ids: ${yamlList(entry.gap_rule_ids ?? [])}`);
+    lines.push(`    retrieval_jobs: ${yamlList(entry.retrieval_jobs)}`);
+  }
+  return { entries, text: `${lines.join("\n")}\n` };
+}
+
+function buildArtifacts(catalogEntries) {
+  const { snapshots } = buildProjectionDefinitions();
+  const analysis = catalogEntries.find((entry) => entry.artifact_kind === "analysis_plan");
+  const artifacts = [
+    artifact("analysis_plan", analysis.name, "Plan d'analyse immeuble", {
+      competency_questions: analysis.competency_questions,
+      expected_focus: ["syndic", "finance", "maintenance", "conformite", "chantier"],
+      refresh_checks: ["projection catalog >= 25", "gap rules >= 25", "expected findings >= 12"]
+    }, "active", "open")
+  ];
+  for (const entry of catalogEntries.filter((row) => row.artifact_kind === "live_answer_view")) {
+    artifacts.push(artifact("live_answer_view", entry.name, entry.label, {
+      source_plan_id: "analysis_plan__immeuble_competency_questions",
+      procedure_id: entry.procedure_id,
+      procedure_area: entry.procedure_area,
+      business_question: entry.business_question,
+      summary: entry.business_question,
+      description: entry.business_question,
+      expected_output: entry.expected_output,
+      refresh_checks: [
+        `${entry.required_schemas[0]} records present`,
+        `required edges: ${entry.required_edges.join(", ")}`
+      ]
+    }));
+  }
+  for (const snapshot of snapshots) {
+    artifacts.push(artifact("answer_snapshot", snapshot.name, snapshot.label, {
+      source_plan_id: "analysis_plan__immeuble_competency_questions",
+      projection_id: snapshot.name,
+      metric: snapshot.metric,
+      summary: snapshot.summary
+    }, "active", "ready", `projection:${snapshot.name}`));
+  }
+  return artifacts;
+}
+
+function writeAnswerSeeds(artifacts) {
+  const lines = artifacts.map((row) => JSON.stringify({
+    kind: "answer_artifact",
+    profile_id: WS,
+    artifact: row
+  }));
+  writeFileSync(paths.answerSeed, `${lines.join("\n")}\n`, "utf8");
+}
+
+function writeBusinessCapabilities(catalogEntries) {
+  const lines = catalogEntries
+    .filter((entry) => entry.artifact_kind === "live_answer_view")
+    .map((entry) => JSON.stringify({
+      kind: "remember",
+      profile_id: WS,
+      schema_id: "ghostcrab:business-capability",
+      content: `Capacite metier immeuble: ${entry.label}.`,
+      facets: {
+        capability_id: entry.name,
+        workspace_id: WS,
+        availability: "live_answer_view",
+        activation_status: "active",
+        label: entry.label,
+        business_question: entry.business_question,
+        example_queries: [entry.label, entry.business_question],
+        required_schemas: entry.required_schemas.map((schema) => `immeuble:core:${schema}`),
+        required_facets: entry.required_facets,
+        artifact_id: `live_answer_view__${entry.name}`,
+        artifact_kind: "live_answer_view",
+        procedure_id: entry.procedure_id,
+        source: "business-capability"
+      }
+    }));
+  writeFileSync(paths.businessSeed, `${lines.join("\n")}\n`, "utf8");
+}
+
+function writeConsumerContract(catalogEntries) {
+  const live = catalogEntries.filter((entry) => entry.artifact_kind === "live_answer_view");
+  const lines = [
+    "workspace_id: immeuble",
+    "",
+    "orphan_entities:",
+    "  max_ratio: 0.50",
+    "  exempt_entity_types: [person, organization, role]",
+    "",
+    "facet_queries:",
+    "  - name: search_building",
+    "    tool: ghostcrab_search",
+    "    schema_id: immeuble:core:building",
+    "    min_rows: 5",
+    "  - name: search_unit",
+    "    tool: ghostcrab_search",
+    "    schema_id: immeuble:core:unit",
+    "    min_rows: 40",
+    "  - name: search_maintenance_ticket",
+    "    tool: ghostcrab_search",
+    "    schema_id: immeuble:core:maintenance_ticket",
+    "    min_rows: 10",
+    "",
+    "graph_traversals:",
+    "  - name: building_contains_units",
+    "    start_entity_type: immeuble:building",
+    "    edge_label: contains",
+    "    min_edges: 40",
+    "  - name: worksite_has_packages",
+    "    start_entity_type: immeuble:worksite_project",
+    "    edge_label: has_work_package",
+    "    min_edges: 3",
+    "",
+    "answer_artifacts:"
+  ];
+  for (const entry of live) {
+    lines.push(`  - name: ${entry.name}`);
+    lines.push("    artifact_kind: live_answer_view");
+    lines.push("    workspace_id: immeuble");
+    lines.push("    min_items: 1");
+  }
+  writeFileSync(paths.consumerContract, `${lines.join("\n")}\n`, "utf8");
+}
+
+function rule(rule_id, entity_type, relation_type, direction, target_entity_type, min_count, severity, label, metadata = {}) {
+  const row = { rule_id, entity_type, relation_type, direction, target_entity_type, min_count, severity, label };
+  if (metadata && Object.keys(metadata).length) row.metadata_json = JSON.stringify(metadata);
+  return row;
+}
+
+function writeRulePack(name, rules, replace = false) {
+  writeFileSync(join(paths.gapRules, name), JSON.stringify({
+    ontology_id: ONT,
+    workspace_id: WS,
+    replace,
+    rules
+  }, null, 2) + "\n", "utf8");
+}
+
+function buildRules() {
+  const activeUnitFilter = { entity_filter: { metadata: { usage_status: { not_one_of: ["vacant_works", "vacant"] } } } };
+  const patrimoine = [
+    rule("unit-one-cellar", "unit", "assigned_cellar", "out", "cellar", 1, "error", "Chaque lot doit avoir une cave assignee"),
+    rule("unit-in-building", "unit", "contains", "in", null, 1, "error", "Chaque lot doit etre rattache a un immeuble ou bloc"),
+    rule("building-has-block", "building", "contains", "out", "block", 1, "error", "Chaque immeuble doit contenir au moins un bloc"),
+    rule("building-has-shared-space", "building", "contains", "out", "shared_space", 1, "warning", "Chaque immeuble doit declarer au moins une partie commune"),
+    rule("meter-measures-asset", "meter", "measures_asset", "out", null, 1, "warning", "Chaque compteur doit mesurer un asset")
+  ];
+  const syndic = [
+    rule("unit-has-owner", "unit", "owns", "in", null, 1, "error", "Chaque lot actif doit avoir un coproprietaire", activeUnitFilter),
+    rule("occupied-unit-has-occupant", "unit", "occupies", "in", "person", 1, "error", "Lot occupe sans occupant declare", activeUnitFilter),
+    rule("tenant-occupied-has-lease", "unit", "leases", "in", "lease_contract", 1, "warning", "Lot loue sans contrat de bail lie", { entity_filter: { metadata: { usage_status: { one_of: ["tenant_occupied", "owner_abroad_tenant"] } } } }),
+    rule("billing-group-bills-unit", "unit", "bills_to", "in", "billing_group", 1, "warning", "Chaque lot actif doit avoir un groupe de facturation", activeUnitFilter),
+    rule("household-has-member", "household", "household_member", "out", "person", 1, "warning", "Chaque menage doit avoir au moins un membre")
+  ];
+  const finance = [
+    rule("charge-call-has-billing-group", "charge_call", "bills_to", "out", "billing_group", 1, "error", "Chaque appel de charges doit cibler un groupe de facturation"),
+    rule("matched-coda-has-charge-call", "coda_entry", "matched_to", "out", "charge_call", 1, "warning", "Chaque CODA rapproche doit pointer vers un appel"),
+    rule("open-charge-has-reminder", "charge_call", "triggered", "out", "reminder", 1, "warning", "Un appel ouvert doit declencher une relance", { entity_filter: { metadata: { status: { one_of: ["open", "overdue"] } } } }),
+    rule("reminder-has-charge-source", "reminder", "triggered", "in", "charge_call", 1, "warning", "Chaque relance doit provenir d'un appel ouvert")
+  ];
+  const exploitation = [
+    rule("service-contract-covers-asset", "service_contract", "covers_asset", "out", null, 1, "error", "Chaque contrat de maintenance doit couvrir un asset"),
+    rule("service-contract-has-provider", "service_contract", "provided_by", "out", "organization", 1, "error", "Chaque contrat de maintenance doit avoir un prestataire"),
+    rule("ticket-concerns-asset", "maintenance_ticket", "concerns_asset", "out", null, 1, "warning", "Chaque ticket doit concerner un asset"),
+    rule("ticket-has-intervention", "maintenance_ticket", "has_intervention", "out", "intervention", 1, "warning", "Chaque ticket doit avoir une intervention planifiee"),
+    rule("intervention-has-provider", "intervention", "provided_by", "out", "organization", 1, "warning", "Chaque intervention doit avoir un prestataire"),
+    rule("claim-covered-by-policy", "claim", "covered_by", "out", "insurance_policy", 1, "error", "Chaque sinistre doit etre relie a une police"),
+    rule("certificate-certifies-asset", "compliance_certificate", "certifies_asset", "out", null, 1, "error", "Chaque certificat doit certifier un asset"),
+    rule("meter-has-recent-reading", "meter", "records_reading", "out", "meter_reading", 1, "warning", "Chaque compteur doit avoir au moins un releve")
+  ];
+  const gouvernance = [
+    rule("ag-has-agenda-item", "ag_meeting", "has_agenda_item", "out", "agenda_item", 1, "warning", "Chaque AG doit avoir un ordre du jour"),
+    rule("agenda-item-has-decision", "agenda_item", "decided_by", "out", "decision", 1, "warning", "Chaque point approuve doit avoir une decision")
+  ];
+  const chantier = [
+    rule("worksite-has-architect", "worksite_project", "designs_for", "in", "architect", 1, "error", "Chaque chantier doit avoir un architecte responsable"),
+    rule("worksite-has-work-package", "worksite_project", "has_work_package", "out", "work_package", 1, "error", "Chaque chantier doit contenir au moins un lot de travaux"),
+    rule("work-package-affects-asset", "work_package", "affects_asset", "out", null, 1, "warning", "Chaque lot de travaux doit affecter au moins un asset"),
+    rule("work-package-has-contractor", "work_package", "executes_work_package", "in", "contractor", 1, "error", "Chaque lot de travaux doit etre lie a une entreprise"),
+    rule("worksite-has-permit", "worksite_project", "authorized_by", "out", "permit", 1, "warning", "Chaque chantier doit etre autorise par un permis ou une decision"),
+    rule("worksite-has-budget-line", "worksite_project", "has_budget_line", "out", "budget_line", 1, "warning", "Chaque chantier doit avoir une ligne budget"),
+    rule("reserve-linked-to-inspection", "defect_reserve", "has_reserve", "in", "inspection", 1, "error", "Chaque reserve doit etre liee a une inspection"),
+    rule("invoice-linked-to-work-package", "invoice", "invoiced_by", "in", "work_package", 1, "warning", "Chaque facture chantier doit etre rattachee a un lot de travaux")
+  ];
+  writeRulePack("L0-patrimoine.json", patrimoine);
+  writeRulePack("L1-syndic.json", syndic);
+  writeRulePack("L2-finance.json", finance);
+  writeRulePack("L2-exploitation.json", exploitation);
+  writeRulePack("L2-maintenance.json", [...exploitation, ...gouvernance]);
+  writeRulePack("L2-chantier.json", chantier);
+  writeRulePack("L3-full.json", [...patrimoine, ...syndic, ...finance, ...exploitation, ...gouvernance, ...chantier], true);
+}
+
+function writeExpectedFindings() {
+  const findings = buildDeltaFindings();
+  const lines = [
+    "workspace_id: immeuble",
+    "ontology_id: immeuble::core",
+    "profile: pedagogical",
+    "expected_findings:"
+  ];
+  for (const finding of findings) {
+    lines.push(`  - id: ${finding.id}`);
+    lines.push(`    rule_id: ${finding.rule_id}`);
+    lines.push(`    severity: ${finding.severity}`);
+    lines.push(`    label: ${yamlScalar(finding.label)}`);
+    lines.push(`    procedure_id: ${finding.procedure_id}`);
+    lines.push(`    entity_id: ${finding.entityId}`);
+  }
+  writeFileSync(join(paths.gapRules, "expected-findings.yaml"), `${lines.join("\n")}\n`, "utf8");
+}
+
+function writeAcceptance() {
+  const text = `# Definition of Done - workspace immeuble
+workspace_id: immeuble
+ontology_id: immeuble::core
+schema_id_prefix: "immeuble:"
+
+import_ready:
+  facet_rows_min: 400
+  edge_rows_min: 800
+  fake_data_csv_min: 35
+  entity_type_counts_min:
+    building: 5
+    block: 9
+    unit: 40
+    household: 40
+    cellar: 40
+    person: 80
+    charge_call: 50
+    coda_entry: 35
+    maintenance_ticket: 10
+    worksite_project: 2
+
+db_after_import:
+  agent_facts_min: 400
+  relations_raw_min: 800
+  graph_entity_min: 400
+  schema_id_violations: 0
+
+hybrid_compare:
+  required: false
+  max_deltas:
+    facets_inserted: 0
+    edges_inserted: 0
+    entities_upserted: 0
+
+projections:
+  analysis_plan_min: 1
+  live_answer_view_min: 25
+  answer_snapshot_min: 8
+
+consumer_contract:
+  facet_queries_min: 3
+  graph_traversals_min: 2
+  answer_artifacts_min: 25
+
+business_capabilities:
+  active_min: 25
+  required_artifact_ids:
+    - live_answer_view__lots_sans_proprietaire
+    - live_answer_view__coda_a_rapprocher
+    - live_answer_view__interventions_en_retard
+    - live_answer_view__chantier_actif
+
+starterkit_projection_audit:
+  quality_score_min: 70
+  required_facet_observation_gap_max: 0
+  required_schema_record_gap_max: 0
+  required_edge_type_gap_max: 0
+  planned_missing_count_max: 0
+  strict_only: true
+
+bundle:
+  path: bundle/immeuble.bundle.json
+  documents_raw_min: 20
+  entities_raw_min: 400
+  relations_raw_min: 800
+  answer_artifacts_min: 33
+
+graph_search_min:
+  query: appartement
+  min_hits: 40
+
+construction_lite:
+  entity_types_min: 14
+  graph_entities_min: 30
+  live_answer_views_min: 6
+  projection_results_min: 8
+  delta_findings_min: 12
+  gap_rules_min: 25
+
+expected_findings:
+  file: gap-rules/expected-findings.yaml
+  min_count: 12
+`;
+  writeFileSync(paths.acceptance, text, "utf8");
+}
+
+function writeSuccessCriteria() {
+  const text = `workspace_id: immeuble
+golden_workspace_id: immeuble
+parity_note: Single canonical workspace - bundle and structured-import share immeuble
+
+entity_counts_min:
+  buildings: 5
+  blocks: 9
+  units: 40
+  households: 40
+  cellars: 40
+  lease_contracts: 10
+  coda_entries: 35
+  persons: 80
+  maintenance_tickets: 10
+  worksite_projects: 2
+
+relation_edges:
+  - contains
+  - owns
+  - occupies
+  - leases
+  - bills_to
+  - matched_to
+  - has_intervention
+  - covers_asset
+  - certified_asset
+  - has_work_package
+
+graph_search_min:
+  appartement: 40
+
+diagnostics:
+  rules_pack: gap-rules/L3-full.json
+  expected_findings: gap-rules/expected-findings.yaml
+  missing_required_relations_min: 12
+`;
+  writeFileSync(paths.successCriteria, text, "utf8");
+}
+
+function writeSourceDocs() {
+  mkdirSync(paths.docs, { recursive: true });
+  const docs = {
+    "procedures-operationnelles.md": "# Procedures operationnelles demo\n\nLa demo couvre proprietaires, occupants, baux, charges, CODA, relances, AG, maintenance, conformite, sinistres et chantiers.\n",
+    "trous-pedagogiques.md": "# Trous pedagogiques attendus\n\nLes donnees contiennent volontairement des proprietaires manquants, occupants manquants, contrats incomplets, relances sans preuve, certificats expires et chantiers a risque.\n"
+  };
+  for (const [name, content] of Object.entries(docs)) {
+    writeFileSync(join(paths.docs, name), content, "utf8");
+  }
+}
+
+function main() {
+  mkdirSync(paths.gapRules, { recursive: true });
+  const bundle = JSON.parse(readFileSync(paths.bundle, "utf8"));
+
+  for (const key of ["entities_raw", "relations_raw", "documents_raw", "chunks_raw", "entity_aliases_raw", "entity_documents_raw", "entity_chunks_raw"]) {
+    bundle[key] ??= [];
+  }
+
+  bundle.entities_raw = bundle.entities_raw.filter((row) => Number(row.entity_id) < GENERATED_MIN_ID && parseMeta(row.metadata_json).generated_by !== GENERATED_TAG);
+  bundle.relations_raw = bundle.relations_raw.filter((row) => Number(row.relation_id) < GENERATED_REL_MIN_ID && parseMeta(row.metadata_json).generated_by !== GENERATED_TAG);
+  bundle.documents_raw = bundle.documents_raw.filter((row) => parseMeta(row.metadata_json).generated_by !== GENERATED_TAG);
+  bundle.chunks_raw = bundle.chunks_raw.filter((row) => parseMeta(row.metadata_json).generated_by !== GENERATED_TAG);
+  bundle.entity_aliases_raw = bundle.entity_aliases_raw.filter((row) => Number(row.entity_id) < GENERATED_MIN_ID);
+  bundle.entity_documents_raw = bundle.entity_documents_raw.filter((row) => Number(row.entity_id) < GENERATED_MIN_ID && Number(row.doc_id) < 100);
+  bundle.entity_chunks_raw = bundle.entity_chunks_raw.filter((row) => Number(row.entity_id) < GENERATED_MIN_ID && Number(row.doc_id) < 100);
+
+  for (const type of [
+    "ag_meeting", "agenda_item", "service_contract", "maintenance_ticket", "intervention",
+    "insurance_policy", "claim", "meter", "meter_reading", "compliance_certificate"
+  ]) {
+    addType(bundle, type, type, "operations");
+  }
+  for (const [edge, source, target] of [
+    ["covers_asset", "Entity", "Asset"],
+    ["provided_by", "Entity", "organization"],
+    ["concerns_asset", "Entity", "Asset"],
+    ["has_intervention", "maintenance_ticket", "intervention"],
+    ["covered_by", "claim", "insurance_policy"],
+    ["certifies_asset", "compliance_certificate", "Asset"],
+    ["measures_asset", "meter", "Asset"],
+    ["records_reading", "meter", "meter_reading"],
+    ["has_agenda_item", "ag_meeting", "agenda_item"],
+    ["flags_entity", "DeltaFinding", "Entity"]
+  ]) {
+    addEdgeType(bundle, edge, source, target);
+  }
+
+  buildPortfolioData(bundle);
+
+  const { entries, text } = buildProjectionCatalog();
+  const artifacts = buildArtifacts(entries);
+  bundle.mindbrain_answer_artifacts = artifacts;
+  writeFileSync(paths.projectionCatalog, text, "utf8");
+  writeAnswerSeeds(artifacts);
+  writeBusinessCapabilities(entries);
+  writeConsumerContract(entries);
+  buildRules();
+  writeExpectedFindings();
+  writeAcceptance();
+  writeSuccessCriteria();
+  writeSourceDocs();
+
+  writeFileSync(paths.bundle, JSON.stringify(bundle, null, 2) + "\n", "utf8");
+  console.log(JSON.stringify({
+    ok: true,
+    entities_raw: bundle.entities_raw.length,
+    relations_raw: bundle.relations_raw.length,
+    documents_raw: bundle.documents_raw.length,
+    answer_artifacts: bundle.mindbrain_answer_artifacts.length,
+    projection_catalog: entries.length
+  }, null, 2));
+}
+
+main();