Remove superseded status and filter non-government bills from matching

Replace the superseded commitment status with update_existing in the
reconciler — restated commitments now get their text updated with a
revision entry, while truly incompatible ones are marked abandoned.

Filter out private members' bills and senate public bills from the
commitment relevance matching pipeline, since they don't represent
government action. Clean up existing bad matches and tainted criteria.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: xrendan

app/avo/resources/commitment.rb

@@ -1,5 +1,5 @@
 class Avo::Resources::Commitment < Avo::BaseResource
-  self.includes = [ :government, :parent, :superseded_by, :policy_area ]
+  self.includes = [ :government, :parent, :policy_area ]
   self.search = {
     query: -> { query.ransack(title_cont: params[:q], m: "or").result(distinct: false) }
   }
@@ -22,7 +22,6 @@ def fields
     field :government, as: :belongs_to
     field :policy_area, as: :belongs_to
     field :parent, as: :belongs_to
-    field :superseded_by, as: :belongs_to
     field :lead_department, as: :has_one
 
     field :children, as: :has_many

app/controllers/api/burndown_controller.rb

@@ -1,6 +1,6 @@
 module Api
   class BurndownController < ApplicationController
-    STARTED_STATUSES = %w[in_progress partially_implemented implemented abandoned superseded].freeze
+    STARTED_STATUSES = %w[in_progress partially_implemented implemented abandoned].freeze
     COMPLETED_STATUSES = %w[implemented].freeze
 
     def show
@@ -17,7 +17,7 @@ def show
       mandate_end = government.mandate_end
 
       # Build events from commitments and status changes
-      commitment_records = commitments.select(:id, :status, :created_at)
+      commitment_records = commitments.select(:id, :status, :date_promised, :created_at)
       commitment_ids = commitment_records.map(&:id)
 
       status_changes = CommitmentStatusChange
@@ -32,14 +32,28 @@ def show
         first_change_by_commitment[sc.commitment_id] ||= sc.previous_status
       end
 
+      # For commitments already in a started status without status_change records,
+      # use their earliest evidence date instead of date_promised
+      earliest_evidence_dates = earliest_evidence_dates_for(commitment_ids)
+
       # Build sorted events
       events = []
 
       commitment_records.each do |c|
         initial = first_change_by_commitment[c.id] || c.status
-        events << { date: c.created_at.to_date, delta_scope: 1,
-                    delta_started: STARTED_STATUSES.include?(initial) ? 1 : 0,
-                    delta_completed: COMPLETED_STATUSES.include?(initial) ? 1 : 0 }
+        scope_date = c.date_promised || c.created_at.to_date
+
+        # Scope always enters on date_promised
+        events << { date: scope_date, delta_scope: 1, delta_started: 0, delta_completed: 0 }
+
+        # Started/completed enter on evidence date (if no status_change drove it)
+        next if first_change_by_commitment.key?(c.id)
+
+        if STARTED_STATUSES.include?(initial)
+          evidence_date = earliest_evidence_dates[c.id] || scope_date
+          events << { date: evidence_date, delta_scope: 0, delta_started: 1,
+                      delta_completed: COMPLETED_STATUSES.include?(initial) ? 1 : 0 }
+        end
       end
 
       status_changes.each do |sc|
@@ -95,5 +109,37 @@ def show
         series: series
       }
     end
+
+    private
+
+    def earliest_evidence_dates_for(commitment_ids)
+      # Find the earliest real-world date from each commitment's matched evidence.
+      # For Bills: use the earliest milestone date (first reading, latest_activity, etc.)
+      # For StatcanDatasets: use last_synced_at
+      matches = CommitmentMatch.where(commitment_id: commitment_ids).includes(:matchable)
+
+      result = {}
+      matches.each do |cm|
+        date = evidence_date_for(cm.matchable)
+        next unless date
+
+        existing = result[cm.commitment_id]
+        result[cm.commitment_id] = date if existing.nil? || date < existing
+      end
+
+      result
+    end
+
+    def evidence_date_for(matchable)
+      case matchable
+      when Bill
+        [
+          matchable.passed_house_first_reading_at,
+          matchable.latest_activity_at
+        ].compact.min&.to_date
+      when StatcanDataset
+        matchable.last_synced_at&.to_date
+      end
+    end
   end
 end

app/jobs/commitment_relevance_filter_job.rb

@@ -2,6 +2,8 @@ class CommitmentRelevanceFilterJob < ApplicationJob
   queue_as :default
 
   def perform(matchable)
+    return if matchable.is_a?(Bill) && !matchable.government_bill?
+
     commitments = active_commitments_for(matchable)
     return if commitments.none?
 
@@ -29,7 +31,7 @@ def perform(matchable)
   private
 
   def active_commitments_for(matchable)
-    scope = Commitment.where.not(status: [:abandoned, :superseded])
+    scope = Commitment.where.not(status: :abandoned)
 
     if matchable.respond_to?(:government_id) && matchable.government_id.present?
       scope.where(government_id: matchable.government_id)

app/jobs/source_document_processor_job.rb

@@ -35,6 +35,7 @@ def perform(source_document)
     created_commitments = create_commitments(deduped, source_document.government, source, policy_areas, departments)
 
     set_parent_relationships(created_commitments, deduped)
+    reconcile_commitments(created_commitments, source_document, source)
 
     source_document.update!(
       status: :extracted,
@@ -128,6 +129,7 @@ def create_commitments(extracted, government, source, policy_areas, departments)
           cs.reference = data["source_reference"]
           cs.excerpt = data["original_text"]&.truncate(500)
         end
+        update_commitment_if_drifted(commitment, data, source)
         created[data["title"]] = commitment
         next
       end
@@ -176,4 +178,70 @@ def set_parent_relationships(created, extracted)
       child.update!(parent: parent) unless child.parent_id == parent.id
     end
   end
+
+  def update_commitment_if_drifted(commitment, data, source)
+    tracked_fields = %w[title description original_text]
+    changes = {}
+
+    tracked_fields.each do |field|
+      new_value = data[field]
+      next if new_value.blank?
+      next if commitment.send(field) == new_value
+      changes[field] = new_value
+    end
+
+    return if changes.empty?
+
+    old_values = {
+      title: commitment.title,
+      description: commitment.description,
+      original_text: commitment.original_text
+    }
+    new_values = old_values.merge(changes.symbolize_keys)
+
+    summarizer = CommitmentDriftSummarizer.create!(record: commitment)
+    summarizer.extract!(summarizer.prompt(old_values, new_values))
+
+    commitment.drift_source = source
+    commitment.drift_change_summary = summarizer.change_summary
+    commitment.update!(changes)
+  end
+
+  def reconcile_commitments(created_commitments, source_document, source)
+    created_ids = created_commitments.values.map(&:id)
+    active_commitments = Commitment.where(government: source_document.government)
+                                   .where.not(id: created_ids)
+                                   .where.not(status: :abandoned)
+
+    return if active_commitments.empty?
+
+    reconciler = CommitmentReconciler.create!(record: source_document)
+    reconciler.extract!(reconciler.prompt(created_commitments.values, active_commitments))
+
+    (reconciler.update_existing || []).each do |entry|
+      existing = Commitment.find_by(id: entry["existing_commitment_id"])
+      new_commitment = created_commitments.values.find { |c| c.title == entry["new_commitment_title"] }
+      next unless existing && new_commitment
+
+      data = {
+        "title" => new_commitment.title,
+        "description" => new_commitment.description,
+        "original_text" => new_commitment.original_text
+      }
+      update_commitment_if_drifted(existing, data, source)
+
+      new_commitment.commitment_sources.update_all(commitment_id: existing.id)
+      new_commitment.destroy!
+      created_commitments.delete(entry["new_commitment_title"])
+    end
+
+    (reconciler.abandoned || []).each do |entry|
+      next unless entry["confidence"].to_f >= 0.6
+      commitment = Commitment.find_by(id: entry["commitment_id"])
+      next unless commitment
+
+      commitment.abandonment_reason = entry["reason"]
+      commitment.update!(status: :abandoned)
+    end
+  end
 end

app/models/bill.rb

@@ -1,6 +1,14 @@
 class Bill < ApplicationRecord
+  GOVERNMENT_BILL_TYPES = [ "House Government Bill", "Senate Government Bill" ].freeze
+
   has_many :commitment_matches, as: :matchable, dependent: :destroy
 
+  scope :government_bills, -> { where("data->>'BillTypeEn' IN (?)", GOVERNMENT_BILL_TYPES) }
+
+  def government_bill?
+    GOVERNMENT_BILL_TYPES.include?(data&.dig("BillTypeEn"))
+  end
+
   def self.sync_all
     api_bills_array = BillsFetcher.fetch("https://www.parl.ca/legisinfo/en/bills/json")
     bills_attributes = api_bills_array.map { |api_data| attributes_from_api(api_data) }

app/models/commitment.rb

@@ -1,11 +1,11 @@
 class Commitment < ApplicationRecord
+  attr_accessor :drift_source, :drift_change_summary, :abandonment_reason
+
   belongs_to :government
   belongs_to :policy_area, optional: true
   belongs_to :parent, class_name: "Commitment", optional: true
-  belongs_to :superseded_by, class_name: "Commitment", optional: true
 
   has_many :children, class_name: "Commitment", foreign_key: :parent_id, dependent: :destroy
-  has_many :supersedes, class_name: "Commitment", foreign_key: :superseded_by_id, dependent: :nullify
   has_many :commitment_sources, dependent: :destroy
   has_many :sources, through: :commitment_sources
   has_many :criteria, dependent: :destroy
@@ -38,8 +38,7 @@ class Commitment < ApplicationRecord
     in_progress: 1,
     partially_implemented: 2,
     implemented: 3,
-    abandoned: 4,
-    superseded: 5
+    abandoned: 4
   }
 
   validates :title, presence: true
@@ -108,8 +107,11 @@ def track_status_change
     status_changes.create!(
       previous_status: previous,
       new_status: current,
-      changed_at: Time.current
+      changed_at: Time.current,
+      reason: abandonment_reason
     )
+  ensure
+    self.abandonment_reason = nil
   end
 
   def tracking_drift?
@@ -128,7 +130,12 @@ def snapshot_revision
       description: changes[:description] || description,
       original_text: changes[:original_text] || original_text,
       target_date: changes[:target_date] || target_date,
-      revision_date: Date.current
+      revision_date: Date.current,
+      source: drift_source,
+      change_summary: drift_change_summary
     )
+  ensure
+    self.drift_source = nil
+    self.drift_change_summary = nil
   end
 end

app/models/commitment_event.rb

@@ -8,8 +8,7 @@ class CommitmentEvent < ApplicationRecord
     legislative_action: 2,
     funding_allocated: 3,
     status_change: 4,
-    criterion_assessed: 5,
-    superseded: 6
+    criterion_assessed: 5
   }
 
   enum :action_type, {

app/models/commitment_reconciler.rb

@@ -0,0 +1,68 @@
+class CommitmentReconciler < Chat
+  include Structify::Model
+
+  MODEL = "gemini-3.1-pro-preview"
+
+  after_create { with_model(MODEL, provider: :gemini, assume_exists: true) }
+
+  schema_definition do
+    version 1
+    name "CommitmentReconciler"
+    field :update_existing, :array,
+      description: "Existing commitments that have been restated with evolved language, adjusted targets, or updated scope in this document",
+      items: {
+        type: "object", properties: {
+          "existing_commitment_id" => { type: "integer", description: "ID of the existing commitment to update" },
+          "new_commitment_title" => { type: "string", description: "Title of the new commitment that restates it" },
+          "reason" => { type: "string", description: "Brief explanation of what changed" }
+        }
+      }
+    field :abandoned, :array,
+      description: "Existing commitments that appear to have been dropped or abandoned based on this document",
+      items: {
+        type: "object", properties: {
+          "commitment_id" => { type: "integer", description: "ID of the commitment that appears abandoned" },
+          "confidence" => { type: "number", description: "Confidence level from 0.0 to 1.0 that this commitment was truly abandoned" },
+          "reason" => { type: "string", description: "Brief explanation of why this commitment appears abandoned" }
+        }
+      }
+  end
+
+  def system_prompt
+    <<~PROMPT
+      You are a government policy analyst detecting when official commitments have been updated or abandoned.
+
+      Be CONSERVATIVE. Minimize false positives. When in doubt, do not flag.
+
+      Two categories:
+      1. UPDATE EXISTING — same policy goal restated with adjusted wording, targets, or scope.
+         The underlying intent is preserved. Example: spending target increased, program renamed
+         and expanded, deadline extended with new scope.
+      2. ABANDON — fundamentally different approach or explicitly reversed. The old intent is
+         no longer being pursued. Only flag when the document explicitly contradicts or reverses
+         a commitment — omission alone is NOT evidence of abandonment.
+    PROMPT
+  end
+
+  def prompt(new_commitments, existing_commitments)
+    new_list = new_commitments.map { |c| "- [NEW] #{c.title}: #{c.description}" }.join("\n")
+    existing_list = existing_commitments.map { |c| "- [ID: #{c.id}] #{c.title}: #{c.description}" }.join("\n")
+
+    <<~PROMPT
+      A new government source document has been processed. Compare the NEW commitments
+      extracted from it against EXISTING active commitments for the same government.
+
+      Identify:
+      1. UPDATE EXISTING: An existing commitment restated with evolved language, adjusted
+         targets, or updated scope — the same policy goal, just refined.
+      2. ABANDONED: An existing commitment that has been explicitly reversed or contradicted
+         (omission alone is NOT evidence of abandonment).
+
+      NEW COMMITMENTS FROM THIS DOCUMENT:
+      #{new_list}
+
+      EXISTING ACTIVE COMMITMENTS:
+      #{existing_list}
+    PROMPT
+  end
+end

app/models/criterion_assessor.rb

@@ -44,7 +44,7 @@ def prompt(criterion, evidence_items)
     - partially_met: Some evidence of progress but not complete
     - not_met: Evidence exists but shows criterion is not satisfied, or contradictory evidence
     - not_assessed: Insufficient evidence to make any determination
-    - no_longer_applicable: The commitment has been superseded or the criterion is moot
+    - no_longer_applicable: The commitment has been abandoned or the criterion is moot
 
     Be CONSERVATIVE. Only mark as "met" if evidence clearly supports it.
     If current status is already "met" and no contradictory evidence, keep it "met".

app/views/commitments/show.json.jbuilder

@@ -29,14 +29,6 @@ if @commitment.parent
   end
 end
 
-if @commitment.superseded_by
-  json.superseded_by do
-    json.(@commitment.superseded_by, :id, :title)
-  end
-end
-
-json.supersedes @commitment.supersedes, :id, :title, :status
-
 json.children @commitment.children, :id, :title, :status
 
 json.sources @commitment.commitment_sources.includes(:source) do |cs|