Extract-Replace Protocol

┌─────────────────┐         extract         ┌─────────────────────────┐
│     MRS-S       │ ──────────────────────► │  Working Set Envelope   │
│    (Source)     │                         │  (MRS-S + context)      │
│                 │                         └─────────────────────────┘
│                 │                                    │
│                 │                              agent work
│                 │                                    │
│                 │                                    ▼
│                 │                         ┌─────────────────────────┐
│                 │ ◄────────────────────── │       MRS-Ops           │
│                 │    validate + apply     │  (typed operations)     │
└─────────────────┘                         └─────────────────────────┘

ExtractParams {
  measures: Range<UUID>              ; Required: measure UUID range
  instruments: Set<InstrumentId>     ; Required: instruments to include
  voices: Set<VoiceId>?              ; Optional: filter voices
  bundle: BundleId                   ; Lane bundle to grant
  task: String?                      ; Task description
  constraints: List<Constraint>?     ; Validation rules
  context_views: List<ViewType>?     ; Requested context views
}

function extract(source: MRS-S, params: ExtractParams) -> WorkingSetEnvelope:
  
  1. Validate params
     - All requested measure UUIDs exist
     - All requested instruments exist
     - Bundle is valid
  
  2. Compute source hash (SHA-256)
  
  3. Resolve inherited state at extraction start
     - Time signature, key, tempo at first measure
  
  4. Build content
     - Copy measures in UUID range
     - Copy instrument definitions
     - Copy relevant spans (mark boundary crossings)
  
  5. Generate task-adaptive context views
     - Select views based on task type
     - Extract relevant content for each view
  
  6. Build envelope with scope, permissions, context
  
  7. Return WorkingSetEnvelope

function apply(source: MRS-S, ops: MRS-Ops) -> Result<MRS-S>:

  1. Verify source hash (conflict detection)
     - If hash mismatch → return Conflict error
  
  2. Progressive validation
     a) Syntax validation (all ops well-formed)
     b) Reference validation (all IDs exist or valid tmp-ids)
     c) Permission validation (ops within lanes/scope)
     d) Musical rule validation (constraints satisfied)
  
  3. If validation fails → return ValidationError with details
  
  4. Map tmp-ids to UUIDs
     - Generate UUIDs in deterministic order
     - Build id-mapping
  
  5. Apply operations in order
     - For create-event: add to measure
     - For update-event: modify existing event
     - For delete-event: remove from measure
     - For create-span: add to spans section
     - etc.
  
  6. Compute derived fields
     - Calculate :at for new events
     - Update :beat-start if measures inserted
  
  7. Full validation of result
  
  8. Record transaction in audit trail
  
  9. Return updated MRS-S with id-mapping

1. Working Set created with source-hash H1
2. Agent produces operations (takes time)
3. Before applying, orchestrator checks current hash
4. If current hash ≠ H1 → conflict

event.:at = measure.:beat-start + event.beat

1. Compute duration of inserted measure
2. Update :beat-start of all subsequent measures

(mrs-ops-result
  :status partial
  :applied 4
  :rejected 2
  :id-mapping
    (("e1" #uuid "...")
     ("e2" #uuid "...")
     ("e3" #uuid "...")
     ("e4" #uuid "..."))
  :errors
    ((error :op 5 :code MUSIC-001 :message "Tie connects different pitches")
     (error :op 6 :code REF-001 :message "Span references non-existent tmp-id")))

(transaction
  :id #uuid "..."
  :timestamp "2026-01-17T10:30:00Z"
  :agent "countermelody-agent"
  :source-hash "sha256:..."
  :result-hash "sha256:..."
  :ops-applied 6
  :scope (:measures #uuid "..." #uuid "..." :instruments [clarinet-bb])
  :bundle orchestrate
  :id-mapping (...))